fitzroy 1.1.0 → 1.2.0

package/dist/cli.js

@@ -59,35 +59,40 @@ var init_result = __esm({
 });
 
 // src/lib/date-utils.ts
-function parseFootyWireDate(dateStr) {
+function parseFootyWireDate(dateStr, defaultYear) {
   const trimmed = dateStr.trim();
   if (trimmed === "") {
     return null;
   }
   const withoutDow = trimmed.replace(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\w*\s+/i, "");
   const normalised = withoutDow.replace(/-/g, " ");
-  const match = /^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/.exec(normalised);
-  if (!match) {
-    return null;
-  }
-  const [, dayStr, monthStr, yearStr] = match;
-  if (!dayStr || !monthStr || !yearStr) {
-    return null;
-  }
-  const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
-  if (monthIndex === void 0) {
-    return null;
-  }
-  const year = Number.parseInt(yearStr, 10);
-  const day = Number.parseInt(dayStr, 10);
-  const date = new Date(Date.UTC(year, monthIndex, day));
-  if (Number.isNaN(date.getTime())) {
-    return null;
+  const fullMatch = /^(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})$/.exec(normalised);
+  if (fullMatch) {
+    const [, dayStr, monthStr, yearStr] = fullMatch;
+    if (dayStr && monthStr && yearStr) {
+      return buildUtcDate(Number.parseInt(yearStr, 10), monthStr, Number.parseInt(dayStr, 10));
+    }
   }
-  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== monthIndex || date.getUTCDate() !== day) {
-    return null;
+  const shortMatch = /^(\d{1,2})\s+([A-Za-z]+)(?:\s+(\d{1,2}):(\d{2})(am|pm))?$/i.exec(normalised);
+  if (shortMatch && defaultYear != null) {
+    const [, dayStr, monthStr, hourStr, minStr, ampm] = shortMatch;
+    if (!dayStr || !monthStr) return null;
+    const monthIndex = MONTH_ABBREV_TO_INDEX.get(monthStr.toLowerCase());
+    if (monthIndex === void 0) return null;
+    const day = Number.parseInt(dayStr, 10);
+    const hasTime = hourStr && minStr && ampm;
+    if (!hasTime) {
+      return buildUtcDate(defaultYear, monthStr, day);
+    }
+    let aestHours = Number.parseInt(hourStr, 10);
+    const minutes = Number.parseInt(minStr, 10);
+    if (ampm.toLowerCase() === "pm" && aestHours < 12) aestHours += 12;
+    if (ampm.toLowerCase() === "am" && aestHours === 12) aestHours = 0;
+    const date = new Date(Date.UTC(defaultYear, monthIndex, day, aestHours - 10, minutes));
+    if (Number.isNaN(date.getTime())) return null;
+    return date;
   }
-  return date;
+  return null;
 }
 function parseAflTablesDate(dateStr) {
   const trimmed = dateStr.trim();
@@ -622,7 +627,7 @@ function parseMatchList(html, year) {
     const scoreLink = scoreCell.find("a").attr("href") ?? "";
     const midMatch = /mid=(\d+)/.exec(scoreLink);
     const matchId = midMatch?.[1] ? `FW_${midMatch[1]}` : `FW_${year}_R${currentRound}_${homeTeam}`;
-    const date = parseFootyWireDate(dateText) ?? new Date(year, 0, 1);
+    const date = parseFootyWireDate(dateText, year) ?? new Date(Date.UTC(year, 0, 1));
     const homeGoals = Math.floor(homePoints / 6);
     const homeBehinds = homePoints - homeGoals * 6;
     const awayGoals = Math.floor(awayPoints / 6);
@@ -692,7 +697,7 @@ function parseFixtureList(html, year) {
     if (teamLinks.length < 2) return;
     const homeTeam = normaliseTeamName($(teamLinks[0]).text().trim());
     const awayTeam = normaliseTeamName($(teamLinks[1]).text().trim());
-    const date = parseFootyWireDate(dateText) ?? new Date(year, 0, 1);
+    const date = parseFootyWireDate(dateText, year) ?? new Date(Date.UTC(year, 0, 1));
     gameNumber++;
     const scoreCell = cells.length >= 5 ? $(cells[4]) : null;
     const scoreText = scoreCell?.text().trim() ?? "";
@@ -780,6 +785,12 @@ function mergeTeamAndOppStats(teamStats, oppStats) {
 function teamNameToFootyWireSlug(teamName) {
   return FOOTYWIRE_SLUG_MAP.get(teamName);
 }
+function normaliseDob(raw) {
+  if (!raw) return null;
+  const parsed = parseFootyWireDate(raw);
+  if (parsed) return parsed.toISOString().slice(0, 10);
+  return raw;
+}
 function parseFootyWirePlayerList(html, teamName) {
   const $ = cheerio2.load(html);
   const players = [];
@@ -821,7 +832,7 @@ function parseFootyWirePlayerList(html, teamName) {
       team: teamName,
       jumperNumber,
       position: position || null,
-      dateOfBirth: dobText || null,
+      dateOfBirth: normaliseDob(dobText),
       heightCm,
       weightKg: null,
       gamesPlayed,
@@ -1290,9 +1301,30 @@ var init_coaches_votes = __esm({
   }
 });
 
+// src/lib/concurrency.ts
+async function batchedMap(items, fn, options) {
+  const batchSize = options?.batchSize ?? 5;
+  const delayMs = options?.delayMs ?? 0;
+  const results = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    const batch = items.slice(i, i + batchSize);
+    const batchResults = await Promise.all(batch.map(fn));
+    results.push(...batchResults);
+    if (delayMs > 0 && i + batchSize < items.length) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  return results;
+}
+var init_concurrency = __esm({
+  "src/lib/concurrency.ts"() {
+    "use strict";
+  }
+});
+
 // src/lib/validation.ts
 import { z } from "zod/v4";
-var AflApiTokenSchema, CompetitionSchema, CompetitionListSchema, CompseasonSchema, CompseasonListSchema, RoundSchema, RoundListSchema, ScoreSchema, PeriodScoreSchema, TeamScoreSchema, CfsMatchTeamSchema, CfsMatchSchema, CfsScoreSchema, CfsVenueSchema, MatchItemSchema, MatchItemListSchema, CfsPlayerInnerSchema, PlayerGameStatsSchema, PlayerStatsItemSchema, PlayerStatsListSchema, RosterPlayerSchema, TeamPlayersSchema, MatchRosterSchema, TeamItemSchema, TeamListSchema, SquadPlayerInnerSchema, SquadPlayerItemSchema, SquadSchema, SquadListSchema, WinLossRecordSchema, LadderEntryRawSchema, LadderResponseSchema;
+var AflApiTokenSchema, CompetitionSchema, CompetitionListSchema, CompseasonSchema, CompseasonListSchema, RoundSchema, RoundListSchema, ScoreSchema, PeriodScoreSchema, TeamScoreSchema, CfsMatchTeamSchema, CfsMatchSchema, CfsScoreSchema, CfsVenueSchema, MatchItemSchema, MatchItemListSchema, CfsPlayerInnerSchema, statNum, PlayerGameStatsSchema, PlayerStatsItemSchema, PlayerStatsListSchema, RosterPlayerSchema, TeamPlayersSchema, MatchRosterSchema, TeamItemSchema, TeamListSchema, SquadPlayerInnerSchema, SquadPlayerItemSchema, SquadSchema, SquadListSchema, WinLossRecordSchema, LadderEntryRawSchema, LadderResponseSchema;
 var init_validation = __esm({
   "src/lib/validation.ts"() {
     "use strict";
@@ -1399,71 +1431,72 @@ var init_validation = __esm({
       captain: z.boolean().optional(),
       playerJumperNumber: z.number().optional()
     }).passthrough();
+    statNum = z.number().nullable().optional();
     PlayerGameStatsSchema = z.object({
-      goals: z.number().optional(),
-      behinds: z.number().optional(),
-      kicks: z.number().optional(),
-      handballs: z.number().optional(),
-      disposals: z.number().optional(),
-      marks: z.number().optional(),
-      bounces: z.number().optional(),
-      tackles: z.number().optional(),
-      contestedPossessions: z.number().optional(),
-      uncontestedPossessions: z.number().optional(),
-      totalPossessions: z.number().optional(),
-      inside50s: z.number().optional(),
-      marksInside50: z.number().optional(),
-      contestedMarks: z.number().optional(),
-      hitouts: z.number().optional(),
-      onePercenters: z.number().optional(),
-      disposalEfficiency: z.number().optional(),
-      clangers: z.number().optional(),
-      freesFor: z.number().optional(),
-      freesAgainst: z.number().optional(),
-      dreamTeamPoints: z.number().optional(),
+      goals: statNum,
+      behinds: statNum,
+      kicks: statNum,
+      handballs: statNum,
+      disposals: statNum,
+      marks: statNum,
+      bounces: statNum,
+      tackles: statNum,
+      contestedPossessions: statNum,
+      uncontestedPossessions: statNum,
+      totalPossessions: statNum,
+      inside50s: statNum,
+      marksInside50: statNum,
+      contestedMarks: statNum,
+      hitouts: statNum,
+      onePercenters: statNum,
+      disposalEfficiency: statNum,
+      clangers: statNum,
+      freesFor: statNum,
+      freesAgainst: statNum,
+      dreamTeamPoints: statNum,
       clearances: z.object({
-        centreClearances: z.number().optional(),
-        stoppageClearances: z.number().optional(),
-        totalClearances: z.number().optional()
-      }).passthrough().optional(),
-      rebound50s: z.number().optional(),
-      goalAssists: z.number().optional(),
-      goalAccuracy: z.number().optional(),
-      turnovers: z.number().optional(),
-      intercepts: z.number().optional(),
-      tacklesInside50: z.number().optional(),
-      shotsAtGoal: z.number().optional(),
-      metresGained: z.number().optional(),
-      scoreInvolvements: z.number().optional(),
-      ratingPoints: z.number().optional(),
+        centreClearances: statNum,
+        stoppageClearances: statNum,
+        totalClearances: statNum
+      }).passthrough().nullable().optional(),
+      rebound50s: statNum,
+      goalAssists: statNum,
+      goalAccuracy: statNum,
+      turnovers: statNum,
+      intercepts: statNum,
+      tacklesInside50: statNum,
+      shotsAtGoal: statNum,
+      metresGained: statNum,
+      scoreInvolvements: statNum,
+      ratingPoints: statNum,
       extendedStats: z.object({
-        effectiveDisposals: z.number().optional(),
-        effectiveKicks: z.number().optional(),
-        kickEfficiency: z.number().optional(),
-        kickToHandballRatio: z.number().optional(),
-        pressureActs: z.number().optional(),
-        defHalfPressureActs: z.number().optional(),
-        spoils: z.number().optional(),
-        hitoutsToAdvantage: z.number().optional(),
-        hitoutWinPercentage: z.number().optional(),
-        hitoutToAdvantageRate: z.number().optional(),
-        groundBallGets: z.number().optional(),
-        f50GroundBallGets: z.number().optional(),
-        interceptMarks: z.number().optional(),
-        marksOnLead: z.number().optional(),
-        contestedPossessionRate: z.number().optional(),
-        contestOffOneOnOnes: z.number().optional(),
-        contestOffWins: z.number().optional(),
-        contestOffWinsPercentage: z.number().optional(),
-        contestDefOneOnOnes: z.number().optional(),
-        contestDefLosses: z.number().optional(),
-        contestDefLossPercentage: z.number().optional(),
-        centreBounceAttendances: z.number().optional(),
-        kickins: z.number().optional(),
-        kickinsPlayon: z.number().optional(),
-        ruckContests: z.number().optional(),
-        scoreLaunches: z.number().optional()
-      }).passthrough().optional()
+        effectiveDisposals: statNum,
+        effectiveKicks: statNum,
+        kickEfficiency: statNum,
+        kickToHandballRatio: statNum,
+        pressureActs: statNum,
+        defHalfPressureActs: statNum,
+        spoils: statNum,
+        hitoutsToAdvantage: statNum,
+        hitoutWinPercentage: statNum,
+        hitoutToAdvantageRate: statNum,
+        groundBallGets: statNum,
+        f50GroundBallGets: statNum,
+        interceptMarks: statNum,
+        marksOnLead: statNum,
+        contestedPossessionRate: statNum,
+        contestOffOneOnOnes: statNum,
+        contestOffWins: statNum,
+        contestOffWinsPercentage: statNum,
+        contestDefOneOnOnes: statNum,
+        contestDefLosses: statNum,
+        contestDefLossPercentage: statNum,
+        centreBounceAttendances: statNum,
+        kickins: statNum,
+        kickinsPlayon: statNum,
+        ruckContests: statNum,
+        scoreLaunches: statNum
+      }).passthrough().nullable().optional()
     }).passthrough();
     PlayerStatsItemSchema = z.object({
       player: z.object({
@@ -1476,7 +1509,7 @@ var init_validation = __esm({
       teamId: z.string(),
       playerStats: z.object({
         stats: PlayerGameStatsSchema,
-        timeOnGroundPercentage: z.number().optional()
+        timeOnGroundPercentage: z.number().nullable().optional()
       }).passthrough()
     }).passthrough();
     PlayerStatsListSchema = z.object({
@@ -1577,6 +1610,7 @@ var TOKEN_URL, API_BASE, CFS_BASE, AflApiClient;
 var init_afl_api = __esm({
   "src/sources/afl-api.ts"() {
     "use strict";
+    init_concurrency();
     init_errors();
     init_result();
     init_validation();
@@ -1587,6 +1621,7 @@ var init_afl_api = __esm({
       fetchFn;
       tokenUrl;
       cachedToken = null;
+      pendingAuth = null;
       constructor(options) {
         this.fetchFn = options?.fetchFn ?? globalThis.fetch;
         this.tokenUrl = options?.tokenUrl ?? TOKEN_URL;
@@ -1594,9 +1629,21 @@ var init_afl_api = __esm({
       /**
        * Authenticate with the WMCTok token endpoint and cache the token.
        *
+       * Concurrent callers share the same in-flight request to avoid
+       * redundant token fetches (thundering herd prevention).
+       *
        * @returns The access token on success, or an error Result.
        */
       async authenticate() {
+        if (this.pendingAuth) {
+          return this.pendingAuth;
+        }
+        this.pendingAuth = this.doAuthenticate().finally(() => {
+          this.pendingAuth = null;
+        });
+        return this.pendingAuth;
+      }
+      async doAuthenticate() {
         try {
           const response = await this.fetchFn(this.tokenUrl, {
             method: "POST",
@@ -1851,7 +1898,7 @@ var init_afl_api = __esm({
           return roundsResult;
         }
         const providerIds = roundsResult.data.flatMap((r) => r.providerId ? [r.providerId] : []);
-        const results = await Promise.all(providerIds.map((id) => this.fetchRoundMatchItems(id)));
+        const results = await batchedMap(providerIds, (id) => this.fetchRoundMatchItems(id));
         const allItems = [];
         for (const result of results) {
           if (!result.success) {
@@ -2209,8 +2256,9 @@ async function fetchFixture(query) {
   const roundProviderIds = roundsResult.data.flatMap(
     (r) => r.providerId ? [{ providerId: r.providerId, roundNumber: r.roundNumber }] : []
   );
-  const roundResults = await Promise.all(
-    roundProviderIds.map((r) => client.fetchRoundMatchItems(r.providerId))
+  const roundResults = await batchedMap(
+    roundProviderIds,
+    (r) => client.fetchRoundMatchItems(r.providerId)
   );
   const fixtures = [];
   for (let i = 0; i < roundResults.length; i++) {
@@ -2226,6 +2274,7 @@ async function fetchFixture(query) {
 var init_fixture = __esm({
   "src/api/fixture.ts"() {
     "use strict";
+    init_concurrency();
     init_errors();
     init_result();
     init_team_mapping();
@@ -2486,6 +2535,7 @@ function parseAflTablesTeamStats(html, year) {
     $(rows[0]).find("td, th").each((_ci, cell) => {
       headers.push($(cell).text().trim());
     });
+    const gpColIdx = headers.findIndex((h, i) => i > 0 && GP_HEADERS.has(h.toLowerCase()));
     for (let ri = 1; ri < rows.length; ri++) {
       const cells = $(rows[ri]).find("td");
       if (cells.length < 3) continue;
@@ -2498,7 +2548,12 @@ function parseAflTablesTeamStats(html, year) {
       }
       const entry = teamMap.get(teamName);
       if (!entry) continue;
+      if (gpColIdx >= 0 && suffix === "_for") {
+        const gpVal = Number.parseFloat($(cells[gpColIdx]).text().trim().replace(/,/g, "")) || 0;
+        entry.gamesPlayed = gpVal;
+      }
       for (let ci = 1; ci < cells.length; ci++) {
+        if (ci === gpColIdx) continue;
         const header = headers[ci];
         if (!header) continue;
         const value = Number.parseFloat($(cells[ci]).text().trim().replace(/,/g, "")) || 0;
@@ -2574,7 +2629,7 @@ function parseAflTablesPlayerList(html, teamName) {
   });
   return players;
 }
-var AFL_TABLES_BASE, AflTablesClient, AFL_TABLES_SLUG_MAP;
+var AFL_TABLES_BASE, AflTablesClient, GP_HEADERS, AFL_TABLES_SLUG_MAP;
 var init_afl_tables = __esm({
   "src/sources/afl-tables.ts"() {
     "use strict";
@@ -2756,6 +2811,7 @@ var init_afl_tables = __esm({
         }
       }
     };
+    GP_HEADERS = /* @__PURE__ */ new Set(["gm", "gp", "p", "mp", "games"]);
     AFL_TABLES_SLUG_MAP = /* @__PURE__ */ new Map([
       ["Adelaide Crows", "adelaide"],
       ["Brisbane Lions", "brisbane"],
@@ -3015,8 +3071,9 @@ async function fetchLineup(query) {
   if (matchItems.data.length === 0) {
     return err(new AflApiError(`No matches found for round ${query.round}`));
   }
-  const rosterResults = await Promise.all(
-    matchItems.data.map((item) => client.fetchMatchRoster(item.match.matchId))
+  const rosterResults = await batchedMap(
+    matchItems.data,
+    (item) => client.fetchMatchRoster(item.match.matchId)
   );
   const lineups = [];
   for (const rosterResult of rosterResults) {
@@ -3028,6 +3085,7 @@ async function fetchLineup(query) {
 var init_lineup2 = __esm({
   "src/api/lineup.ts"() {
     "use strict";
+    init_concurrency();
     init_errors();
     init_result();
     init_afl_api();
@@ -3310,15 +3368,26 @@ async function fetchPlayerStats(query) {
     case "afl-api": {
       const client = new AflApiClient();
       if (query.matchId) {
-        const result = await client.fetchPlayerStats(query.matchId);
-        if (!result.success) return result;
+        const [rosterResult, statsResult] = await Promise.all([
+          client.fetchMatchRoster(query.matchId),
+          client.fetchPlayerStats(query.matchId)
+        ]);
+        if (!statsResult.success) return statsResult;
+        const teamIdMap2 = /* @__PURE__ */ new Map();
+        if (rosterResult.success) {
+          const match = rosterResult.data.match;
+          teamIdMap2.set(match.homeTeamId, match.homeTeam.name);
+          teamIdMap2.set(match.awayTeamId, match.awayTeam.name);
+        }
         return ok(
           transformPlayerStats(
-            result.data,
+            statsResult.data,
             query.matchId,
             query.season,
             query.round ?? 0,
-            competition
+            competition,
+            "afl-api",
+            teamIdMap2.size > 0 ? teamIdMap2 : void 0
           )
         );
       }
@@ -3335,8 +3404,9 @@ async function fetchPlayerStats(query) {
         teamIdMap.set(item.match.homeTeamId, item.match.homeTeam.name);
         teamIdMap.set(item.match.awayTeamId, item.match.awayTeam.name);
       }
-      const statsResults = await Promise.all(
-        matchItemsResult.data.map((item) => client.fetchPlayerStats(item.match.matchId))
+      const statsResults = await batchedMap(
+        matchItemsResult.data,
+        (item) => client.fetchPlayerStats(item.match.matchId)
       );
       const allStats = [];
       for (let i = 0; i < statsResults.length; i++) {
@@ -3404,6 +3474,7 @@ async function fetchPlayerStats(query) {
 var init_player_stats2 = __esm({
   "src/api/player-stats.ts"() {
     "use strict";
+    init_concurrency();
     init_errors();
     init_result();
     init_afl_api();
@@ -3526,6 +3597,94 @@ var init_index = __esm({
   }
 });
 
+// src/cli/flags.ts
+var SEASON_FLAG, OPTIONAL_SEASON_FLAG, ROUND_FLAG, REQUIRED_ROUND_FLAG, SOURCE_FLAG, COMPETITION_FLAG, OPTIONAL_COMPETITION_FLAG, OUTPUT_FLAGS, REQUIRED_TEAM_FLAG, TEAM_FLAG, PLAYER_FLAG;
+var init_flags = __esm({
+  "src/cli/flags.ts"() {
+    "use strict";
+    SEASON_FLAG = {
+      season: {
+        type: "string",
+        description: "Season year (e.g. 2025)",
+        required: true,
+        alias: "s"
+      }
+    };
+    OPTIONAL_SEASON_FLAG = {
+      season: {
+        type: "string",
+        description: "Season year (e.g. 2025)",
+        alias: "s"
+      }
+    };
+    ROUND_FLAG = {
+      round: {
+        type: "string",
+        description: "Round number",
+        alias: "r"
+      }
+    };
+    REQUIRED_ROUND_FLAG = {
+      round: {
+        type: "string",
+        description: "Round number",
+        required: true,
+        alias: "r"
+      }
+    };
+    SOURCE_FLAG = {
+      source: {
+        type: "string",
+        description: "Data source",
+        default: "afl-api"
+      }
+    };
+    COMPETITION_FLAG = {
+      competition: {
+        type: "string",
+        description: "Competition code (AFLM or AFLW)",
+        default: "AFLM",
+        alias: "c"
+      }
+    };
+    OPTIONAL_COMPETITION_FLAG = {
+      competition: {
+        type: "string",
+        description: "Competition code (AFLM or AFLW)",
+        alias: "c"
+      }
+    };
+    OUTPUT_FLAGS = {
+      json: { type: "boolean", description: "Output as JSON", alias: "j" },
+      csv: { type: "boolean", description: "Output as CSV" },
+      format: { type: "string", description: "Output format: table, json, csv" },
+      full: { type: "boolean", description: "Show all columns in table output" }
+    };
+    REQUIRED_TEAM_FLAG = {
+      team: {
+        type: "string",
+        description: "Team name, abbreviation, or ID (e.g. Carlton, CARL, 5)",
+        required: true,
+        alias: "t"
+      }
+    };
+    TEAM_FLAG = {
+      team: {
+        type: "string",
+        description: "Filter by team name",
+        alias: "t"
+      }
+    };
+    PLAYER_FLAG = {
+      player: {
+        type: "string",
+        description: "Filter by player name",
+        alias: "p"
+      }
+    };
+  }
+});
+
 // src/cli/formatters/csv.ts
 function escapeField(value) {
   if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r")) {
@@ -3570,7 +3729,7 @@ var init_json = __esm({
 // src/cli/formatters/table.ts
 function toDisplayValue(value) {
   if (value === null || value === void 0) return "-";
-  if (value instanceof Date) return value.toISOString().slice(0, 16).replace("T", " ");
+  if (value instanceof Date) return AEST_COMPACT_FORMATTER.format(value);
   if (typeof value === "object") return JSON.stringify(value);
   return String(value);
 }
@@ -3644,9 +3803,18 @@ function formatTable(data, options = {}) {
   });
   return [header, separator, ...rows].join("\n");
 }
+var AEST_COMPACT_FORMATTER;
 var init_table = __esm({
   "src/cli/formatters/table.ts"() {
     "use strict";
+    AEST_COMPACT_FORMATTER = new Intl.DateTimeFormat("en-AU", {
+      timeZone: "Australia/Melbourne",
+      day: "numeric",
+      month: "short",
+      hour: "numeric",
+      minute: "2-digit",
+      hour12: true
+    });
   }
 });
 
@@ -3686,7 +3854,7 @@ var init_formatters = __esm({
 
 // src/cli/ui.ts
 import { spinner } from "@clack/prompts";
-import pc from "picocolors";
+import pc2 from "picocolors";
 async function withSpinner(message, fn) {
   if (!isTTY) {
     return fn();
@@ -3704,7 +3872,7 @@ async function withSpinner(message, fn) {
 }
 function showSummary(message) {
   if (!isTTY) return;
-  console.error(pc.dim(message));
+  console.error(pc2.dim(message));
 }
 var isTTY;
 var init_ui = __esm({
@@ -3714,6 +3882,109 @@ var init_ui = __esm({
   }
 });
 
+// src/cli/validation.ts
+function validateSeason(raw) {
+  const season = Number(raw);
+  if (Number.isNaN(season) || !Number.isInteger(season)) {
+    throw new Error(`Invalid season: "${raw}" \u2014 season must be a number (e.g. 2025)`);
+  }
+  if (season < 1897 || season > 2100) {
+    throw new Error(`Invalid season: ${season} \u2014 must be between 1897 and 2100`);
+  }
+  return season;
+}
+function validateOptionalSeason(raw) {
+  if (raw != null) return validateSeason(raw);
+  return void 0;
+}
+function resolveDefaultSeason(competition = "AFLM") {
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  return competition === "AFLW" ? year - 1 : year;
+}
+function validateRound(raw) {
+  const round = Number(raw);
+  if (Number.isNaN(round) || !Number.isInteger(round) || round < 0) {
+    throw new Error(`Invalid round: "${raw}" \u2014 round must be a non-negative integer`);
+  }
+  return round;
+}
+function validateFormat(raw) {
+  if (raw == null) return void 0;
+  const lower = raw.toLowerCase();
+  if (VALID_FORMATS.includes(lower)) {
+    return lower;
+  }
+  throw new Error(`Invalid format: "${raw}" \u2014 valid formats are: ${VALID_FORMATS.join(", ")}`);
+}
+function validateCompetition(raw) {
+  const upper = raw.toUpperCase();
+  if (upper === "AFLM" || upper === "AFLW") {
+    return upper;
+  }
+  throw new Error(
+    `Invalid competition: "${raw}" \u2014 valid values are: ${VALID_COMPETITIONS.join(", ")}`
+  );
+}
+function validateOptionalCompetition(raw) {
+  if (raw == null) return void 0;
+  return validateCompetition(raw);
+}
+function validateSource(raw) {
+  if (VALID_SOURCES.includes(raw)) {
+    return raw;
+  }
+  throw new Error(`Invalid source: "${raw}" \u2014 valid sources are: ${VALID_SOURCES.join(", ")}`);
+}
+function resolveTeamIdentifier(raw, teams) {
+  const trimmed = raw.trim();
+  if (/^\d+$/.test(trimmed)) {
+    return trimmed;
+  }
+  const canonical = normaliseTeamName(trimmed);
+  const byCanonical = teams.find((t) => t.name === canonical);
+  if (byCanonical) return byCanonical.teamId;
+  const lower = trimmed.toLowerCase();
+  const byName = teams.find((t) => t.name.toLowerCase() === lower);
+  if (byName) return byName.teamId;
+  const byAbbrev = teams.find((t) => t.abbreviation.toLowerCase() === lower);
+  if (byAbbrev) return byAbbrev.teamId;
+  const validNames = teams.map((t) => `${t.name} (${t.abbreviation})`).join(", ");
+  throw new Error(`Unknown team: "${raw}" \u2014 valid teams are: ${validNames}`);
+}
+function resolveMatchByTeam(teamSearch, matchItems) {
+  const normalised = normaliseTeamName(teamSearch);
+  const lower = teamSearch.toLowerCase();
+  const matches = matchItems.filter((item) => {
+    const home = item.match.homeTeam.name;
+    const away = item.match.awayTeam.name;
+    return normaliseTeamName(home) === normalised || normaliseTeamName(away) === normalised || home.toLowerCase().includes(lower) || away.toLowerCase().includes(lower);
+  });
+  const singleMatch = matches[0];
+  if (matches.length === 1 && singleMatch) {
+    return singleMatch.match.matchId;
+  }
+  if (matches.length === 0) {
+    const available = matchItems.map((item) => `${item.match.homeTeam.name} vs ${item.match.awayTeam.name}`).join(", ");
+    throw new Error(
+      `No match found for "${teamSearch}" in this round. Available matches: ${available}`
+    );
+  }
+  const ambiguous = matches.map((item) => `${item.match.homeTeam.name} vs ${item.match.awayTeam.name}`).join(", ");
+  throw new Error(
+    `Multiple matches found for "${teamSearch}": ${ambiguous}. Please be more specific.`
+  );
+}
+var VALID_SOURCES, VALID_COMPETITIONS, VALID_FORMATS;
+var init_validation2 = __esm({
+  "src/cli/validation.ts"() {
+    "use strict";
+    init_team_mapping();
+    VALID_SOURCES = ["afl-api", "footywire", "afl-tables", "squiggle"];
+    VALID_COMPETITIONS = ["AFLM", "AFLW"];
+    VALID_FORMATS = ["table", "json", "csv"];
+  }
+});
+
 // src/cli/commands/matches.ts
 var matches_exports = {};
 __export(matches_exports, {
@@ -3725,8 +3996,10 @@ var init_matches = __esm({
   "src/cli/commands/matches.ts"() {
     "use strict";
     init_index();
+    init_flags();
     init_formatters();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS = [
       { key: "date", label: "Date", maxWidth: 16 },
       { key: "roundNumber", label: "Round", maxWidth: 6 },
@@ -3742,30 +4015,21 @@ var init_matches = __esm({
         description: "Fetch match results for a season"
       },
       args: {
-        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-        round: { type: "string", description: "Round number" },
-        source: { type: "string", description: "Data source", default: "afl-api" },
-        competition: {
-          type: "string",
-          description: "Competition code (AFLM or AFLW)",
-          default: "AFLM"
-        },
-        json: { type: "boolean", description: "Output as JSON" },
-        csv: { type: "boolean", description: "Output as CSV" },
-        format: { type: "string", description: "Output format: table, json, csv" },
-        full: { type: "boolean", description: "Show all columns in table output" }
+        ...SEASON_FLAG,
+        ...ROUND_FLAG,
+        ...SOURCE_FLAG,
+        ...COMPETITION_FLAG,
+        ...OUTPUT_FLAGS
       },
       async run({ args }) {
-        const season = Number(args.season);
-        const round = args.round ? Number(args.round) : void 0;
+        const season = validateSeason(args.season);
+        const round = args.round ? validateRound(args.round) : void 0;
+        const source = validateSource(args.source);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
         const result = await withSpinner(
           "Fetching match results\u2026",
-          () => fetchMatchResults({
-            source: args.source,
-            season,
-            round,
-            competition: args.competition
-          })
+          () => fetchMatchResults({ source, season, round, competition })
         );
         if (!result.success) {
           throw result.error;
@@ -3775,7 +4039,7 @@ var init_matches = __esm({
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS
         };
@@ -3785,6 +4049,203 @@ var init_matches = __esm({
   }
 });
 
+// src/lib/fuzzy.ts
+function levenshteinDistance(a, b) {
+  const la = a.length;
+  const lb = b.length;
+  if (la === 0) return lb;
+  if (lb === 0) return la;
+  if (la < lb) return levenshteinDistance(b, a);
+  const row = Array.from({ length: lb + 1 }, (_, i) => i);
+  for (let i = 1; i <= la; i++) {
+    let prev = i;
+    for (let j = 1; j <= lb; j++) {
+      const current = row[j - 1];
+      const rowJ = row[j];
+      if (current === void 0 || rowJ === void 0) continue;
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      const val = Math.min(rowJ + 1, prev + 1, current + cost);
+      row[j - 1] = prev;
+      prev = val;
+    }
+    row[lb] = prev;
+  }
+  return row[lb] ?? 0;
+}
+function fuzzySearch(query, candidates, keySelector, options) {
+  const maxResults = options?.maxResults ?? 10;
+  const threshold = options?.threshold ?? 0.4;
+  const lowerQuery = query.toLowerCase();
+  const results = [];
+  for (const item of candidates) {
+    const key = keySelector(item).toLowerCase();
+    if (key === lowerQuery) {
+      results.push({ item, score: 0 });
+      continue;
+    }
+    if (key.startsWith(lowerQuery)) {
+      results.push({ item, score: 0.1 });
+      continue;
+    }
+    if (key.includes(lowerQuery)) {
+      results.push({ item, score: 0.3 });
+      continue;
+    }
+    const maxLen = Math.max(lowerQuery.length, key.length);
+    if (maxLen === 0) continue;
+    const distance = levenshteinDistance(lowerQuery, key);
+    const normalised = distance / maxLen;
+    if (normalised <= threshold) {
+      const score = 0.4 + normalised / threshold * 0.6;
+      results.push({ item, score });
+    }
+  }
+  results.sort((a, b) => {
+    if (a.score !== b.score) return a.score - b.score;
+    return keySelector(a.item).localeCompare(keySelector(b.item));
+  });
+  return results.slice(0, maxResults);
+}
+var init_fuzzy = __esm({
+  "src/lib/fuzzy.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/resolvers.ts
+import { isCancel, select } from "@clack/prompts";
+async function resolveTeamOrPrompt(query, teams) {
+  try {
+    return resolveTeamIdentifier(query, teams);
+  } catch {
+  }
+  const matches = fuzzySearch(query.trim(), teams, (t) => t.name, {
+    maxResults: 5,
+    threshold: 0.4
+  });
+  const abbrevMatches = fuzzySearch(query.trim(), teams, (t) => t.abbreviation, {
+    maxResults: 5,
+    threshold: 0.4
+  });
+  const seen = new Set(matches.map((m) => m.item.teamId));
+  for (const m of abbrevMatches) {
+    if (!seen.has(m.item.teamId)) {
+      matches.push(m);
+      seen.add(m.item.teamId);
+    }
+  }
+  matches.sort((a, b) => a.score - b.score);
+  return disambiguate(
+    query.trim(),
+    matches.map((m) => ({ value: m.item.teamId, label: m.item.name, score: m.score })),
+    teams.map((t) => `${t.name} (${t.abbreviation})`),
+    "team"
+  );
+}
+async function resolveTeamNameOrPrompt(query, teamNames) {
+  const trimmed = query.trim();
+  const canonical = normaliseTeamName(trimmed);
+  const candidates = teamNames ?? [...AFL_SENIOR_TEAMS];
+  if (candidates.includes(canonical)) {
+    return canonical;
+  }
+  const items = candidates.map((name) => ({ name }));
+  const matches = fuzzySearch(trimmed, items, (t) => t.name, {
+    maxResults: 5,
+    threshold: 0.4
+  });
+  return disambiguate(
+    trimmed,
+    matches.map((m) => ({ value: m.item.name, label: m.item.name, score: m.score })),
+    candidates,
+    "team"
+  );
+}
+async function resolveMatchOrPrompt(query, matchItems) {
+  try {
+    return resolveMatchByTeam(query, matchItems);
+  } catch {
+  }
+  const labelledItems = matchItems.map((item) => ({
+    item,
+    label: `${item.match.homeTeam.name} vs ${item.match.awayTeam.name}`
+  }));
+  const matches = fuzzySearch(query, labelledItems, (l) => l.label, {
+    maxResults: 5,
+    threshold: 0.5
+  });
+  const homeMatches = fuzzySearch(query, matchItems, (i) => i.match.homeTeam.name, {
+    maxResults: 5,
+    threshold: 0.4
+  });
+  const awayMatches = fuzzySearch(query, matchItems, (i) => i.match.awayTeam.name, {
+    maxResults: 5,
+    threshold: 0.4
+  });
+  const seen = new Set(matches.map((m) => m.item.item.match.matchId));
+  for (const m of homeMatches) {
+    if (!seen.has(m.item.match.matchId)) {
+      const label = `${m.item.match.homeTeam.name} vs ${m.item.match.awayTeam.name}`;
+      matches.push({ item: { item: m.item, label }, score: m.score });
+      seen.add(m.item.match.matchId);
+    }
+  }
+  for (const m of awayMatches) {
+    if (!seen.has(m.item.match.matchId)) {
+      const label = `${m.item.match.homeTeam.name} vs ${m.item.match.awayTeam.name}`;
+      matches.push({ item: { item: m.item, label }, score: m.score });
+      seen.add(m.item.match.matchId);
+    }
+  }
+  matches.sort((a, b) => a.score - b.score);
+  const available = matchItems.map(
+    (item) => `${item.match.homeTeam.name} vs ${item.match.awayTeam.name}`
+  );
+  return disambiguate(
+    query,
+    matches.map((m) => ({
+      value: m.item.item.match.matchId,
+      label: m.item.label,
+      score: m.score
+    })),
+    available,
+    "match"
+  );
+}
+async function disambiguate(query, options, allLabels, entityName) {
+  const best = options[0];
+  if (!best) {
+    throw new Error(
+      `No ${entityName} found for "${query}". Valid options: ${allLabels.join(", ")}`
+    );
+  }
+  if (best.score < 0.2 || options.length === 1) {
+    return best.value;
+  }
+  if (isTTY2) {
+    const choice = await select({
+      message: `Multiple ${entityName}s matched "${query}". Which did you mean?`,
+      options: options.map((o) => ({ value: o.value, label: o.label }))
+    });
+    if (isCancel(choice)) {
+      process.exit(0);
+    }
+    return choice;
+  }
+  console.error(`Matched "${query}" \u2192 ${best.label}`);
+  return best.value;
+}
+var isTTY2;
+var init_resolvers = __esm({
+  "src/cli/resolvers.ts"() {
+    "use strict";
+    init_fuzzy();
+    init_team_mapping();
+    init_validation2();
+    isTTY2 = process.stdout.isTTY === true;
+  }
+});
+
 // src/cli/commands/stats.ts
 var stats_exports = {};
 __export(stats_exports, {
@@ -3796,8 +4257,13 @@ var init_stats = __esm({
   "src/cli/commands/stats.ts"() {
     "use strict";
     init_index();
+    init_fuzzy();
+    init_afl_api();
+    init_flags();
     init_formatters();
+    init_resolvers();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS2 = [
       { key: "displayName", label: "Player", maxWidth: 22 },
       { key: "team", label: "Team", maxWidth: 18 },
@@ -3813,45 +4279,54 @@ var init_stats = __esm({
         description: "Fetch player statistics for a season"
       },
       args: {
-        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-        round: { type: "string", description: "Round number" },
-        "match-id": { type: "string", description: "Specific match ID" },
-        source: { type: "string", description: "Data source", default: "afl-api" },
-        competition: {
-          type: "string",
-          description: "Competition code (AFLM or AFLW)",
-          default: "AFLM"
-        },
-        json: { type: "boolean", description: "Output as JSON" },
-        csv: { type: "boolean", description: "Output as CSV" },
-        format: { type: "string", description: "Output format: table, json, csv" },
-        full: { type: "boolean", description: "Show all columns in table output" }
+        ...SEASON_FLAG,
+        ...ROUND_FLAG,
+        match: { type: "string", description: "Filter by team name to find a specific match" },
+        "match-id": { type: "string", description: "Specific match provider ID (advanced)" },
+        ...SOURCE_FLAG,
+        ...COMPETITION_FLAG,
+        ...PLAYER_FLAG,
+        ...OUTPUT_FLAGS
       },
       async run({ args }) {
-        const season = Number(args.season);
-        const round = args.round ? Number(args.round) : void 0;
-        const matchId = args["match-id"];
+        const season = validateSeason(args.season);
+        const round = args.round ? validateRound(args.round) : void 0;
+        const source = validateSource(args.source);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
+        let matchId = args["match-id"];
+        if (!matchId && args.match && round != null) {
+          const client = new AflApiClient();
+          const seasonResult = await client.resolveCompSeason(competition, season);
+          if (!seasonResult.success) throw seasonResult.error;
+          const itemsResult = await client.fetchRoundMatchItemsByNumber(seasonResult.data, round);
+          if (!itemsResult.success) throw itemsResult.error;
+          matchId = await resolveMatchOrPrompt(args.match, itemsResult.data);
+        } else if (args.match && round == null) {
+          throw new Error("--match requires --round (-r) to identify which round to search.");
+        }
         const result = await withSpinner(
           "Fetching player stats\u2026",
-          () => fetchPlayerStats({
-            source: args.source,
-            season,
-            round,
-            matchId,
-            competition: args.competition
-          })
+          () => fetchPlayerStats({ source, season, round, matchId, competition })
         );
         if (!result.success) {
           throw result.error;
         }
-        const data = result.data;
+        let data = result.data;
+        if (args.player) {
+          const playerMatches = fuzzySearch(args.player, data, (p) => p.displayName, {
+            maxResults: 50,
+            threshold: 0.4
+          });
+          data = playerMatches.map((m) => m.item);
+        }
         showSummary(
           `Loaded ${data.length} player stat lines for ${season}${round ? ` round ${round}` : ""}`
         );
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS2
         };
@@ -3872,8 +4347,10 @@ var init_fixture2 = __esm({
   "src/cli/commands/fixture.ts"() {
     "use strict";
     init_index();
+    init_flags();
     init_formatters();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS3 = [
       { key: "roundNumber", label: "Round", maxWidth: 6 },
       { key: "date", label: "Date", maxWidth: 16 },
@@ -3887,30 +4364,21 @@ var init_fixture2 = __esm({
         description: "Fetch fixture/schedule for a season"
       },
       args: {
-        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-        round: { type: "string", description: "Round number" },
-        source: { type: "string", description: "Data source", default: "afl-api" },
-        competition: {
-          type: "string",
-          description: "Competition code (AFLM or AFLW)",
-          default: "AFLM"
-        },
-        json: { type: "boolean", description: "Output as JSON" },
-        csv: { type: "boolean", description: "Output as CSV" },
-        format: { type: "string", description: "Output format: table, json, csv" },
-        full: { type: "boolean", description: "Show all columns in table output" }
+        ...SEASON_FLAG,
+        ...ROUND_FLAG,
+        ...SOURCE_FLAG,
+        ...COMPETITION_FLAG,
+        ...OUTPUT_FLAGS
       },
       async run({ args }) {
-        const season = Number(args.season);
-        const round = args.round ? Number(args.round) : void 0;
+        const season = validateSeason(args.season);
+        const round = args.round ? validateRound(args.round) : void 0;
+        const source = validateSource(args.source);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
         const result = await withSpinner(
           "Fetching fixture\u2026",
-          () => fetchFixture({
-            source: args.source,
-            season,
-            round,
-            competition: args.competition
-          })
+          () => fetchFixture({ source, season, round, competition })
         );
         if (!result.success) {
           throw result.error;
@@ -3920,7 +4388,7 @@ var init_fixture2 = __esm({
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS3
         };
@@ -3941,8 +4409,10 @@ var init_ladder3 = __esm({
   "src/cli/commands/ladder.ts"() {
     "use strict";
     init_index();
+    init_flags();
     init_formatters();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS4 = [
       { key: "position", label: "Pos", maxWidth: 4 },
       { key: "team", label: "Team", maxWidth: 24 },
@@ -3958,30 +4428,21 @@ var init_ladder3 = __esm({
         description: "Fetch ladder standings for a season"
       },
       args: {
-        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-        round: { type: "string", description: "Round number" },
-        source: { type: "string", description: "Data source", default: "afl-api" },
-        competition: {
-          type: "string",
-          description: "Competition code (AFLM or AFLW)",
-          default: "AFLM"
-        },
-        json: { type: "boolean", description: "Output as JSON" },
-        csv: { type: "boolean", description: "Output as CSV" },
-        format: { type: "string", description: "Output format: table, json, csv" },
-        full: { type: "boolean", description: "Show all columns in table output" }
+        ...SEASON_FLAG,
+        ...ROUND_FLAG,
+        ...SOURCE_FLAG,
+        ...COMPETITION_FLAG,
+        ...OUTPUT_FLAGS
       },
       async run({ args }) {
-        const season = Number(args.season);
-        const round = args.round ? Number(args.round) : void 0;
+        const season = validateSeason(args.season);
+        const round = args.round ? validateRound(args.round) : void 0;
+        const source = validateSource(args.source);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
         const result = await withSpinner(
           "Fetching ladder\u2026",
-          () => fetchLadder({
-            source: args.source,
-            season,
-            round,
-            competition: args.competition
-          })
+          () => fetchLadder({ source, season, round, competition })
         );
         if (!result.success) {
           throw result.error;
@@ -3993,7 +4454,7 @@ var init_ladder3 = __esm({
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS4
         };
@@ -4009,17 +4470,45 @@ __export(lineup_exports, {
   lineupCommand: () => lineupCommand
 });
 import { defineCommand as defineCommand5 } from "citty";
+function flattenLineups(lineups) {
+  const rows = [];
+  for (const lineup of lineups) {
+    for (const { players, team } of [
+      { players: lineup.homePlayers, team: lineup.homeTeam },
+      { players: lineup.awayPlayers, team: lineup.awayTeam }
+    ]) {
+      for (const p of players) {
+        rows.push({
+          matchId: lineup.matchId,
+          team,
+          displayName: p.displayName,
+          jumperNumber: p.jumperNumber,
+          position: p.position,
+          isEmergency: p.isEmergency,
+          isSubstitute: p.isSubstitute
+        });
+      }
+    }
+  }
+  return rows;
+}
 var DEFAULT_COLUMNS5, lineupCommand;
 var init_lineup3 = __esm({
   "src/cli/commands/lineup.ts"() {
     "use strict";
     init_index();
+    init_afl_api();
+    init_flags();
     init_formatters();
+    init_resolvers();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS5 = [
-      { key: "matchId", label: "Match", maxWidth: 12 },
-      { key: "homeTeam", label: "Home", maxWidth: 20 },
-      { key: "awayTeam", label: "Away", maxWidth: 20 }
+      { key: "matchId", label: "Match", maxWidth: 14 },
+      { key: "team", label: "Team", maxWidth: 20 },
+      { key: "displayName", label: "Player", maxWidth: 24 },
+      { key: "jumperNumber", label: "#", maxWidth: 4 },
+      { key: "position", label: "Pos", maxWidth: 12 }
     ];
     lineupCommand = defineCommand5({
       meta: {
@@ -4027,33 +4516,32 @@ var init_lineup3 = __esm({
         description: "Fetch match lineups for a round"
       },
       args: {
-        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-        round: { type: "string", description: "Round number", required: true },
-        "match-id": { type: "string", description: "Specific match ID" },
-        source: { type: "string", description: "Data source", default: "afl-api" },
-        competition: {
-          type: "string",
-          description: "Competition code (AFLM or AFLW)",
-          default: "AFLM"
-        },
-        json: { type: "boolean", description: "Output as JSON" },
-        csv: { type: "boolean", description: "Output as CSV" },
-        format: { type: "string", description: "Output format: table, json, csv" },
-        full: { type: "boolean", description: "Show all columns in table output" }
+        ...SEASON_FLAG,
+        ...REQUIRED_ROUND_FLAG,
+        match: { type: "string", description: "Filter by team name to find a specific match" },
+        "match-id": { type: "string", description: "Specific match provider ID (advanced)" },
+        ...SOURCE_FLAG,
+        ...COMPETITION_FLAG,
+        ...OUTPUT_FLAGS
       },
       async run({ args }) {
-        const season = Number(args.season);
-        const round = Number(args.round);
-        const matchId = args["match-id"];
+        const season = validateSeason(args.season);
+        const round = validateRound(args.round);
+        const source = validateSource(args.source);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
+        let matchId = args["match-id"];
+        if (!matchId && args.match) {
+          const client = new AflApiClient();
+          const seasonResult = await client.resolveCompSeason(competition, season);
+          if (!seasonResult.success) throw seasonResult.error;
+          const itemsResult = await client.fetchRoundMatchItemsByNumber(seasonResult.data, round);
+          if (!itemsResult.success) throw itemsResult.error;
+          matchId = await resolveMatchOrPrompt(args.match, itemsResult.data);
+        }
         const result = await withSpinner(
           "Fetching lineups\u2026",
-          () => fetchLineup({
-            source: args.source,
-            season,
-            round,
-            matchId,
-            competition: args.competition
-          })
+          () => fetchLineup({ source, season, round, matchId, competition })
         );
         if (!result.success) {
           throw result.error;
@@ -4063,11 +4551,16 @@ var init_lineup3 = __esm({
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS5
         };
-        console.log(formatOutput(data, formatOptions));
+        const resolvedFormat = resolveFormat(formatOptions);
+        if (resolvedFormat === "json") {
+          console.log(formatOutput(data, formatOptions));
+        } else {
+          console.log(formatOutput(flattenLineups(data), formatOptions));
+        }
       }
     });
   }
@@ -4084,8 +4577,11 @@ var init_squad = __esm({
   "src/cli/commands/squad.ts"() {
     "use strict";
     init_index();
+    init_flags();
     init_formatters();
+    init_resolvers();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS6 = [
       { key: "displayName", label: "Player", maxWidth: 24 },
       { key: "jumperNumber", label: "#", maxWidth: 4 },
@@ -4099,28 +4595,26 @@ var init_squad = __esm({
         description: "Fetch team squad for a season"
       },
       args: {
-        "team-id": { type: "string", description: "Team ID", required: true },
-        season: { type: "string", description: "Season year (e.g. 2025)", required: true },
-        competition: {
-          type: "string",
-          description: "Competition code (AFLM or AFLW)",
-          default: "AFLM"
-        },
-        json: { type: "boolean", description: "Output as JSON" },
-        csv: { type: "boolean", description: "Output as CSV" },
-        format: { type: "string", description: "Output format: table, json, csv" },
-        full: { type: "boolean", description: "Show all columns in table output" }
+        ...REQUIRED_TEAM_FLAG,
+        ...SEASON_FLAG,
+        ...COMPETITION_FLAG,
+        ...OUTPUT_FLAGS
       },
       async run({ args }) {
-        const teamId = args["team-id"];
-        const season = Number(args.season);
+        const season = validateSeason(args.season);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
+        let teamId = args.team.trim();
+        if (!/^\d+$/.test(teamId)) {
+          const teamsResult = await withSpinner("Resolving team\u2026", () => fetchTeams({ competition }));
+          if (!teamsResult.success) {
+            throw teamsResult.error;
+          }
+          teamId = await resolveTeamOrPrompt(args.team, teamsResult.data);
+        }
         const result = await withSpinner(
           "Fetching squad\u2026",
-          () => fetchSquad({
-            teamId,
-            season,
-            competition: args.competition
-          })
+          () => fetchSquad({ teamId, season, competition })
         );
         if (!result.success) {
           throw result.error;
@@ -4130,7 +4624,7 @@ var init_squad = __esm({
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS6
         };
@@ -4151,8 +4645,10 @@ var init_teams2 = __esm({
   "src/cli/commands/teams.ts"() {
     "use strict";
     init_index();
+    init_flags();
     init_formatters();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS7 = [
       { key: "teamId", label: "ID", maxWidth: 8 },
       { key: "name", label: "Team", maxWidth: 24 },
@@ -4165,30 +4661,31 @@ var init_teams2 = __esm({
         description: "Fetch team list"
       },
       args: {
-        competition: { type: "string", description: "Competition code (AFLM or AFLW)" },
+        ...OPTIONAL_COMPETITION_FLAG,
         "team-type": { type: "string", description: "Team type filter" },
-        json: { type: "boolean", description: "Output as JSON" },
-        csv: { type: "boolean", description: "Output as CSV" },
-        format: { type: "string", description: "Output format: table, json, csv" },
-        full: { type: "boolean", description: "Show all columns in table output" }
+        ...OUTPUT_FLAGS
       },
       async run({ args }) {
+        const competition = validateOptionalCompetition(args.competition);
+        const format = validateFormat(args.format);
         const result = await withSpinner(
           "Fetching teams\u2026",
-          () => fetchTeams({
-            competition: args.competition,
-            teamType: args["team-type"]
-          })
+          () => fetchTeams({ competition, teamType: args["team-type"] })
         );
         if (!result.success) {
           throw result.error;
         }
         const data = result.data;
+        if (data.length === 0 && args["team-type"]) {
+          console.error(
+            `No teams found for team type "${args["team-type"]}". Try running without --team-type to see available teams.`
+          );
+        }
         showSummary(`Loaded ${data.length} teams`);
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS7
         };
@@ -4215,11 +4712,21 @@ var init_team_stats2 = __esm({
   "src/cli/commands/team-stats.ts"() {
     "use strict";
     init_index();
+    init_flags();
     init_formatters();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS8 = [
       { key: "team", label: "Team", maxWidth: 24 },
-      { key: "gamesPlayed", label: "GP", maxWidth: 5 }
+      { key: "gamesPlayed", label: "GP", maxWidth: 5 },
+      { key: "K", label: "K", maxWidth: 6 },
+      { key: "HB", label: "HB", maxWidth: 6 },
+      { key: "D", label: "D", maxWidth: 6 },
+      { key: "M", label: "M", maxWidth: 6 },
+      { key: "G", label: "G", maxWidth: 6 },
+      { key: "B", label: "B", maxWidth: 6 },
+      { key: "T", label: "T", maxWidth: 6 },
+      { key: "I50", label: "I50", maxWidth: 6 }
     ];
     teamStatsCommand = defineCommand8({
       meta: {
@@ -4227,28 +4734,23 @@ var init_team_stats2 = __esm({
         description: "Fetch team aggregate statistics for a season"
       },
       args: {
-        season: { type: "string", description: "Season year (e.g. 2024)", required: true },
+        ...SEASON_FLAG,
         source: {
           type: "string",
           description: "Data source (footywire, afl-tables)",
           default: "footywire"
         },
         summary: { type: "string", description: "Summary type: totals or averages", default: "totals" },
-        json: { type: "boolean", description: "Output as JSON" },
-        csv: { type: "boolean", description: "Output as CSV" },
-        format: { type: "string", description: "Output format: table, json, csv" },
-        full: { type: "boolean", description: "Show all columns in table output" }
+        ...OUTPUT_FLAGS
       },
       async run({ args }) {
-        const season = Number(args.season);
+        const season = validateSeason(args.season);
+        const source = validateSource(args.source);
+        const format = validateFormat(args.format);
         const summaryType = args.summary;
         const result = await withSpinner(
           "Fetching team stats\u2026",
-          () => fetchTeamStats({
-            source: args.source,
-            season,
-            summaryType
-          })
+          () => fetchTeamStats({ source, season, summaryType })
         );
         if (!result.success) {
           throw result.error;
@@ -4259,7 +4761,7 @@ var init_team_stats2 = __esm({
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS8
         };
@@ -4280,8 +4782,11 @@ var init_player_details2 = __esm({
   "src/cli/commands/player-details.ts"() {
     "use strict";
     init_index();
+    init_flags();
     init_formatters();
+    init_resolvers();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS9 = [
       { key: "displayName", label: "Player", maxWidth: 24 },
       { key: "jumperNumber", label: "#", maxWidth: 4 },
@@ -4297,44 +4802,35 @@ var init_player_details2 = __esm({
         description: "Fetch player biographical details for a team"
       },
       args: {
-        team: { type: "positional", description: "Team name (e.g. Carlton, Hawthorn)", required: true },
+        ...REQUIRED_TEAM_FLAG,
         source: {
           type: "string",
           description: "Data source: afl-api, footywire, afl-tables",
           default: "afl-api"
         },
-        season: { type: "string", description: "Season year (for AFL API source, e.g. 2025)" },
-        competition: {
-          type: "string",
-          description: "Competition code (AFLM or AFLW)",
-          default: "AFLM"
-        },
-        json: { type: "boolean", description: "Output as JSON" },
-        csv: { type: "boolean", description: "Output as CSV" },
-        format: { type: "string", description: "Output format: table, json, csv" },
-        full: { type: "boolean", description: "Show all columns in table output" }
+        ...OPTIONAL_SEASON_FLAG,
+        ...COMPETITION_FLAG,
+        ...OUTPUT_FLAGS
       },
       async run({ args }) {
-        const source = args.source;
-        const season = args.season ? Number(args.season) : void 0;
+        const source = validateSource(args.source);
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
+        const season = validateOptionalSeason(args.season) ?? resolveDefaultSeason(competition);
+        const team = await resolveTeamNameOrPrompt(args.team);
         const result = await withSpinner(
           "Fetching player details\u2026",
-          () => fetchPlayerDetails({
-            source,
-            team: args.team,
-            season,
-            competition: args.competition
-          })
+          () => fetchPlayerDetails({ source, team, season, competition })
         );
         if (!result.success) {
           throw result.error;
         }
         const data = result.data;
-        showSummary(`Loaded ${data.length} players for ${args.team} (${source})`);
+        showSummary(`Loaded ${data.length} players for ${team} (${source})`);
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS9
         };
@@ -4355,8 +4851,11 @@ var init_coaches_votes2 = __esm({
   "src/cli/commands/coaches-votes.ts"() {
     "use strict";
     init_index();
+    init_flags();
     init_formatters();
+    init_resolvers();
     init_ui();
+    init_validation2();
     DEFAULT_COLUMNS10 = [
       { key: "season", label: "Season", maxWidth: 8 },
       { key: "round", label: "Round", maxWidth: 6 },
@@ -4371,42 +4870,33 @@ var init_coaches_votes2 = __esm({
         description: "Fetch AFLCA coaches votes for a season"
       },
       args: {
-        season: { type: "string", description: "Season year (e.g. 2024)", required: true },
-        round: { type: "string", description: "Round number" },
-        competition: {
-          type: "string",
-          description: "Competition code (AFLM or AFLW)",
-          default: "AFLM"
-        },
-        team: { type: "string", description: "Filter by team name" },
-        json: { type: "boolean", description: "Output as JSON" },
-        csv: { type: "boolean", description: "Output as CSV" },
-        format: { type: "string", description: "Output format: table, json, csv" },
-        full: { type: "boolean", description: "Show all columns in table output" }
+        ...SEASON_FLAG,
+        ...ROUND_FLAG,
+        ...COMPETITION_FLAG,
+        ...TEAM_FLAG,
+        ...OUTPUT_FLAGS
       },
       async run({ args }) {
-        const season = Number(args.season);
-        const round = args.round ? Number(args.round) : void 0;
+        const season = validateSeason(args.season);
+        const round = args.round ? validateRound(args.round) : void 0;
+        const competition = validateCompetition(args.competition);
+        const format = validateFormat(args.format);
+        const team = args.team ? await resolveTeamNameOrPrompt(args.team) : void 0;
         const result = await withSpinner(
           "Fetching coaches votes\u2026",
-          () => fetchCoachesVotes({
-            season,
-            round,
-            competition: args.competition,
-            team: args.team
-          })
+          () => fetchCoachesVotes({ season, round, competition, team })
         );
         if (!result.success) {
           throw result.error;
         }
         const data = result.data;
-        const teamSuffix = args.team ? ` for ${args.team}` : "";
+        const teamSuffix = team ? ` for ${team}` : "";
         const roundSuffix = round ? ` round ${round}` : "";
         showSummary(`Loaded ${data.length} vote records for ${season}${roundSuffix}${teamSuffix}`);
         const formatOptions = {
           json: args.json,
           csv: args.csv,
-          format: args.format,
+          format,
           full: args.full,
           columns: DEFAULT_COLUMNS10
         };
@@ -4417,13 +4907,39 @@ var init_coaches_votes2 = __esm({
 });
 
 // src/cli.ts
-init_errors();
 import { defineCommand as defineCommand11, runMain } from "citty";
-import pc2 from "picocolors";
+
+// src/cli/error-boundary.ts
+init_errors();
+import pc from "picocolors";
+function formatError(error) {
+  if (error instanceof ValidationError && error.issues) {
+    const issueLines = error.issues.map((i) => `  ${pc.yellow(i.path)}: ${i.message}`);
+    return `${pc.red("Validation error:")}
+${issueLines.join("\n")}`;
+  }
+  if (error instanceof AflApiError) {
+    const status = error.statusCode ? ` (HTTP ${error.statusCode})` : "";
+    return `${pc.red("AFL API error:")} ${error.message}${status}`;
+  }
+  if (error instanceof ScrapeError) {
+    const source = error.source ? ` [${error.source}]` : "";
+    return `${pc.red("Scrape error:")} ${error.message}${source}`;
+  }
+  if (error instanceof UnsupportedSourceError) {
+    return `${pc.red("Unsupported source:")} ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return `${pc.red("Error:")} ${error.message}`;
+  }
+  return `${pc.red("Error:")} ${String(error)}`;
+}
+
+// src/cli.ts
 var main = defineCommand11({
   meta: {
     name: "fitzroy",
-    version: "1.1.0",
+    version: "1.2.0",
     description: "CLI for fetching AFL data \u2014 match results, player stats, fixtures, ladders, and more"
   },
   subCommands: {
@@ -4439,28 +4955,6 @@ var main = defineCommand11({
     "coaches-votes": () => Promise.resolve().then(() => (init_coaches_votes2(), coaches_votes_exports)).then((m) => m.coachesVotesCommand)
   }
 });
-function formatError(error) {
-  if (error instanceof ValidationError && error.issues) {
-    const issueLines = error.issues.map((i) => `  ${pc2.yellow(i.path)}: ${i.message}`);
-    return `${pc2.red("Validation error:")}
-${issueLines.join("\n")}`;
-  }
-  if (error instanceof AflApiError) {
-    const status = error.statusCode ? ` (HTTP ${error.statusCode})` : "";
-    return `${pc2.red("AFL API error:")} ${error.message}${status}`;
-  }
-  if (error instanceof ScrapeError) {
-    const source = error.source ? ` [${error.source}]` : "";
-    return `${pc2.red("Scrape error:")} ${error.message}${source}`;
-  }
-  if (error instanceof UnsupportedSourceError) {
-    return `${pc2.red("Unsupported source:")} ${error.message}`;
-  }
-  if (error instanceof Error) {
-    return `${pc2.red("Error:")} ${error.message}`;
-  }
-  return `${pc2.red("Error:")} ${String(error)}`;
-}
 runMain(main).catch((error) => {
   console.error(formatError(error));
   process.exit(1);