bbdata-cli 0.1.0

package/dist/src/index.js

@@ -0,0 +1,1857 @@
+#!/usr/bin/env node
+
+// src/utils/http.ts
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRIES = 2;
+async function fetchWithRetry(url, options = {}) {
+  const { headers, timeout = DEFAULT_TIMEOUT, retries = DEFAULT_RETRIES } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      const response = await fetch(url, {
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText} \u2014 ${url}`);
+      }
+      return response;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < retries) {
+        await new Promise((resolve) => setTimeout(resolve, 1e3 * (attempt + 1)));
+      }
+    }
+  }
+  throw lastError ?? new Error(`Failed to fetch: ${url}`);
+}
+async function fetchJson(url, options) {
+  const response = await fetchWithRetry(url, options);
+  return response.json();
+}
+async function fetchText(url, options) {
+  const response = await fetchWithRetry(url, options);
+  return response.text();
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var isTTY = process.stdout.isTTY ?? false;
+var log = {
+  info(message) {
+    if (isTTY) {
+      process.stderr.write(chalk.blue("\u2139 ") + message + "\n");
+    }
+  },
+  success(message) {
+    if (isTTY) {
+      process.stderr.write(chalk.green("\u2713 ") + message + "\n");
+    }
+  },
+  warn(message) {
+    process.stderr.write(chalk.yellow("\u26A0 ") + message + "\n");
+  },
+  error(message) {
+    process.stderr.write(chalk.red("\u2717 ") + message + "\n");
+  },
+  debug(message) {
+    if (process.env.BBDATA_DEBUG) {
+      process.stderr.write(chalk.gray("\u22EF ") + message + "\n");
+    }
+  },
+  /** Print data to stdout — this is what agents/pipes consume */
+  data(content) {
+    process.stdout.write(content);
+  }
+};
+
+// src/adapters/mlb-stats-api.ts
+var BASE_URL = "https://statsapi.mlb.com/api/v1";
+var MlbStatsApiAdapter = class {
+  source = "mlb-stats-api";
+  description = "Official MLB Stats API \u2014 rosters, schedules, season stats (JSON)";
+  supports(query2) {
+    return true;
+  }
+  async resolvePlayer(name) {
+    log.debug(`MLB API: resolving player "${name}"`);
+    try {
+      const data = await fetchJson(
+        `${BASE_URL}/people/search?names=${encodeURIComponent(name)}&hydrate=currentTeam`
+      );
+      if (!data.people?.length) return null;
+      const player = data.people[0];
+      return {
+        mlbam_id: String(player.id),
+        name: player.fullName,
+        team: player.currentTeam?.abbreviation,
+        position: player.primaryPosition?.abbreviation
+      };
+    } catch (error) {
+      log.warn(`Failed to resolve player "${name}" via MLB API: ${error}`);
+      return null;
+    }
+  }
+  async fetch(query2, options) {
+    let playerId = query2.player_id;
+    let playerName = query2.player_name ?? "Unknown";
+    if (!playerId && query2.player_name) {
+      const resolved = await this.resolvePlayer(query2.player_name);
+      if (!resolved) {
+        throw new Error(`Player not found: "${query2.player_name}"`);
+      }
+      playerId = resolved.mlbam_id;
+      playerName = resolved.name;
+    }
+    const statGroup = query2.stat_type === "batting" ? "hitting" : query2.stat_type;
+    const url = playerId ? `${BASE_URL}/people/${playerId}/stats?stats=season&season=${query2.season}&group=${statGroup}` : `${BASE_URL}/stats?stats=season&season=${query2.season}&group=${statGroup}&gameType=R&limit=50&sortStat=onBasePlusSlugging`;
+    log.debug(`MLB API: fetching ${url}`);
+    const data = await fetchJson(url);
+    const stats = [];
+    for (const statGroup2 of data.stats ?? []) {
+      for (const split of statGroup2.splits ?? []) {
+        stats.push({
+          player_id: playerId ?? String(split.player?.id ?? ""),
+          player_name: playerName ?? split.player?.fullName ?? "Unknown",
+          team: split.team?.abbreviation ?? query2.team ?? "",
+          season: Number(split.season) || query2.season,
+          stat_type: query2.stat_type,
+          stats: split.stat
+        });
+      }
+    }
+    return {
+      data: stats,
+      source: this.source,
+      cached: false,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      meta: {
+        rowCount: stats.length,
+        season: query2.season,
+        query: query2
+      }
+    };
+  }
+};
+
+// src/adapters/savant.ts
+import { parse } from "csv-parse/sync";
+var SAVANT_SEARCH_URL = "https://baseballsavant.mlb.com/statcast_search/csv";
+var SavantAdapter = class {
+  source = "savant";
+  description = "Baseball Savant (Statcast) \u2014 pitch-level data via CSV export";
+  // Use MLB API for player resolution since Savant needs MLBAM IDs
+  mlbApi = new MlbStatsApiAdapter();
+  supports(query2) {
+    return !!(query2.player_name || query2.player_id || query2.start_date && query2.end_date);
+  }
+  async resolvePlayer(name) {
+    return this.mlbApi.resolvePlayer(name);
+  }
+  async fetch(query2, options) {
+    let playerId = query2.player_id;
+    if (!playerId && query2.player_name) {
+      const resolved = await this.resolvePlayer(query2.player_name);
+      if (!resolved) {
+        throw new Error(`Player not found: "${query2.player_name}"`);
+      }
+      playerId = resolved.mlbam_id;
+    }
+    const params = new URLSearchParams({
+      all: "true",
+      type: "detail",
+      ...query2.stat_type === "pitching" ? { player_type: "pitcher", pitchers_lookup: playerId ?? "" } : { player_type: "batter", batters_lookup: playerId ?? "" },
+      ...query2.start_date ? { game_date_gt: query2.start_date } : { game_date_gt: `${query2.season}-01-01` },
+      ...query2.end_date ? { game_date_lt: query2.end_date } : { game_date_lt: `${query2.season}-12-31` }
+    });
+    if (query2.pitch_type?.length) {
+      params.set("pitch_type", query2.pitch_type.join(","));
+    }
+    const url = `${SAVANT_SEARCH_URL}?${params}`;
+    log.info(`Fetching Statcast data from Baseball Savant...`);
+    log.debug(`Savant URL: ${url}`);
+    const csvText = await fetchText(url, { timeout: 6e4 });
+    if (!csvText.trim() || csvText.includes("No Results")) {
+      return {
+        data: [],
+        source: this.source,
+        cached: false,
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        meta: { rowCount: 0, season: query2.season, query: query2 }
+      };
+    }
+    const rawRows = parse(csvText, {
+      columns: true,
+      skip_empty_lines: true,
+      cast: true,
+      cast_date: false
+    });
+    const filteredRows = rawRows.filter(
+      (row) => row.pitch_type && String(row.pitch_type).trim() !== ""
+    );
+    const data = filteredRows.map((row) => ({
+      pitcher_id: String(row.pitcher ?? ""),
+      pitcher_name: String(row.player_name ?? ""),
+      batter_id: String(row.batter ?? ""),
+      batter_name: String(row.batter_name || "") || (row.batter ? `Unknown (#${row.batter})` : "Unknown"),
+      game_date: String(row.game_date ?? ""),
+      pitch_type: String(row.pitch_type ?? ""),
+      release_speed: Number(row.release_speed) || 0,
+      release_spin_rate: Number(row.release_spin_rate) || 0,
+      pfx_x: Number(row.pfx_x) || 0,
+      pfx_z: Number(row.pfx_z) || 0,
+      plate_x: Number(row.plate_x) || 0,
+      plate_z: Number(row.plate_z) || 0,
+      launch_speed: row.launch_speed != null ? Number(row.launch_speed) || null : null,
+      launch_angle: row.launch_angle != null ? Number(row.launch_angle) || null : null,
+      description: String(row.description ?? ""),
+      events: row.events ? String(row.events) : null,
+      bb_type: row.bb_type ? String(row.bb_type) : null,
+      stand: String(row.stand ?? "R"),
+      p_throws: String(row.p_throws ?? "R"),
+      estimated_ba: row.estimated_ba_using_speedangle != null ? Number(row.estimated_ba_using_speedangle) || null : null,
+      estimated_woba: row.estimated_woba_using_speedangle != null ? Number(row.estimated_woba_using_speedangle) || null : null
+    }));
+    log.success(`Fetched ${data.length} pitches from Savant`);
+    return {
+      data,
+      source: this.source,
+      cached: false,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      meta: { rowCount: data.length, season: query2.season, query: query2 }
+    };
+  }
+};
+
+// src/adapters/fangraphs.ts
+var FG_LEADERS_URL = "https://www.fangraphs.com/api/leaders/major-league/data";
+var FanGraphsAdapter = class {
+  source = "fangraphs";
+  description = "FanGraphs \u2014 aggregated stats, leaderboards, WAR, wRC+, FIP";
+  supports(query2) {
+    return true;
+  }
+  async resolvePlayer(name) {
+    log.debug(`FanGraphs: resolving player "${name}" via leaderboard search`);
+    try {
+      const season = (/* @__PURE__ */ new Date()).getFullYear();
+      const params = new URLSearchParams({
+        pos: "all",
+        stats: "bat",
+        lg: "all",
+        qual: "0",
+        season: String(season),
+        month: "0",
+        ind: "0",
+        team: "",
+        pageitems: "500",
+        pagenum: "1",
+        type: "8"
+        // standard stats
+      });
+      const data = await fetchText(`${FG_LEADERS_URL}?${params}`);
+      const parsed = JSON.parse(data);
+      const nameNorm = name.toLowerCase().trim();
+      const players = parsed.data ?? [];
+      const getName = (p) => String(p.PlayerName ?? p.Name ?? "").toLowerCase().trim();
+      let match = players.find((p) => getName(p) === nameNorm);
+      if (!match) {
+        const tokens = nameNorm.split(/\s+/);
+        match = players.find((p) => {
+          const words = getName(p).split(/\s+/);
+          return tokens.every((t) => words.some((w) => w.startsWith(t)));
+        });
+        if (match) {
+          log.debug(`FanGraphs: fuzzy match for "${name}" \u2192 "${getName(match)}"`);
+        }
+      }
+      if (!match) return null;
+      return {
+        mlbam_id: String(match.xMLBAMID ?? ""),
+        fangraphs_id: String(match.playerid ?? ""),
+        name: String(match.PlayerName ?? match.Name),
+        team: String(match.Team ?? "")
+      };
+    } catch (error) {
+      log.warn(`FanGraphs player resolution failed: ${error}`);
+      return null;
+    }
+  }
+  async fetch(query2, options) {
+    const statType = query2.stat_type === "batting" ? "bat" : "pit";
+    const params = new URLSearchParams({
+      pos: "all",
+      stats: statType,
+      lg: "all",
+      qual: String(query2.min_pa ?? query2.min_ip ?? 0),
+      season: String(query2.season),
+      month: "0",
+      ind: "0",
+      team: query2.team ? await this.resolveTeamId(query2.team) : "",
+      pageitems: "500",
+      pagenum: "1",
+      type: "8"
+      // standard + advanced stats
+    });
+    const url = `${FG_LEADERS_URL}?${params}`;
+    log.info("Fetching stats from FanGraphs...");
+    log.debug(`FanGraphs URL: ${url}`);
+    const raw = await fetchText(url);
+    const parsed = JSON.parse(raw);
+    const rows = parsed.data ?? [];
+    let filtered = rows;
+    if (query2.player_name) {
+      const nameNorm = query2.player_name.toLowerCase().trim();
+      const getName = (r) => String(r.PlayerName ?? r.Name ?? "").toLowerCase().trim();
+      const exact = rows.filter((r) => getName(r) === nameNorm);
+      if (exact.length > 0) {
+        filtered = exact;
+      } else {
+        const tokens = nameNorm.split(/\s+/);
+        filtered = rows.filter((r) => {
+          const words = getName(r).split(/\s+/);
+          return tokens.every((t) => words.some((w) => w.startsWith(t)));
+        });
+      }
+    }
+    const stats = filtered.map((row) => ({
+      player_id: String(row.xMLBAMID ?? row.playerid ?? ""),
+      player_name: String(row.PlayerName ?? row.Name ?? ""),
+      team: String(row.Team ?? ""),
+      season: query2.season,
+      stat_type: query2.stat_type,
+      stats: row
+    }));
+    log.success(`Fetched ${stats.length} player(s) from FanGraphs`);
+    return {
+      data: stats,
+      source: this.source,
+      cached: false,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      meta: { rowCount: stats.length, season: query2.season, query: query2 }
+    };
+  }
+  async resolveTeamId(abbrev) {
+    const TEAM_IDS = {
+      LAA: "1",
+      ARI: "15",
+      BAL: "2",
+      BOS: "3",
+      CHC: "17",
+      CHW: "4",
+      CIN: "18",
+      CLE: "5",
+      COL: "19",
+      DET: "6",
+      HOU: "21",
+      KC: "7",
+      LAD: "22",
+      MIA: "20",
+      MIL: "23",
+      MIN: "8",
+      NYM: "25",
+      NYY: "9",
+      OAK: "10",
+      PHI: "26",
+      PIT: "27",
+      SD: "29",
+      SF: "30",
+      SEA: "11",
+      STL: "28",
+      TB: "12",
+      TEX: "13",
+      TOR: "14",
+      WSH: "24",
+      ATL: "16"
+    };
+    return TEAM_IDS[abbrev.toUpperCase()] ?? "";
+  }
+};
+
+// src/adapters/baseball-reference.ts
+var BaseballReferenceAdapter = class {
+  source = "baseball-reference";
+  description = "Baseball Reference \u2014 historical stats, career data (BETA)";
+  supports(_query) {
+    return false;
+  }
+  async resolvePlayer(_name) {
+    log.warn("Baseball Reference adapter is in beta \u2014 player resolution not yet implemented");
+    return null;
+  }
+  async fetch(query2, _options) {
+    log.warn("Baseball Reference adapter is in beta \u2014 returning empty results");
+    return {
+      data: [],
+      source: this.source,
+      cached: false,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      meta: { rowCount: 0, season: query2.season, query: query2 }
+    };
+  }
+};
+
+// src/adapters/index.ts
+var adapters = {
+  "mlb-stats-api": new MlbStatsApiAdapter(),
+  "savant": new SavantAdapter(),
+  "fangraphs": new FanGraphsAdapter(),
+  "baseball-reference": new BaseballReferenceAdapter()
+};
+function resolveAdapters(preferred) {
+  return preferred.map((source) => adapters[source]).filter(Boolean);
+}
+
+// src/formatters/json.ts
+function formatJson(data, meta) {
+  const output = { data, meta };
+  return {
+    raw: data,
+    formatted: JSON.stringify(output, null, 2) + "\n",
+    meta
+  };
+}
+
+// src/formatters/table.ts
+import Table from "cli-table3";
+import chalk2 from "chalk";
+function formatTable(data, meta, options = {}) {
+  if (data.length === 0) {
+    return {
+      raw: data,
+      formatted: "No data found.\n",
+      meta
+    };
+  }
+  const columns = options.columns ?? Object.keys(data[0]);
+  const table = new Table({
+    head: columns.map((col) => chalk2.bold(col)),
+    style: { head: ["cyan"] }
+  });
+  for (const row of data) {
+    table.push(columns.map((col) => formatCell(row[col])));
+  }
+  const footer = chalk2.gray(
+    `
+${meta.sampleSize} rows \xB7 Source: ${meta.source} \xB7 ${meta.cached ? "cached" : "live"}`
+  );
+  return {
+    raw: data,
+    formatted: table.toString() + footer + "\n",
+    meta
+  };
+}
+function formatCell(value) {
+  if (value === null || value === void 0) return chalk2.gray("\u2014");
+  if (typeof value === "number") {
+    if (Math.abs(value) <= 1 && value !== 0) {
+      return (value * 100).toFixed(1) + "%";
+    }
+    if (Number.isInteger(value) && value > 999) {
+      return value.toLocaleString();
+    }
+    return value.toFixed(1);
+  }
+  return String(value);
+}
+
+// src/formatters/csv.ts
+import { stringify } from "csv-stringify/sync";
+function formatCsv(data, meta) {
+  if (data.length === 0) {
+    return { raw: data, formatted: "", meta };
+  }
+  const columns = Object.keys(data[0]);
+  const formatted = stringify(data, { header: true, columns });
+  return { raw: data, formatted, meta };
+}
+
+// src/formatters/markdown.ts
+function formatMarkdown(data, meta) {
+  if (data.length === 0) {
+    return { raw: data, formatted: "*No data found.*\n", meta };
+  }
+  const columns = Object.keys(data[0]);
+  const header = "| " + columns.join(" | ") + " |";
+  const separator = "| " + columns.map(() => "---").join(" | ") + " |";
+  const rows = data.map(
+    (row) => "| " + columns.map((col) => formatMdCell(row[col])).join(" | ") + " |"
+  );
+  const footer = `
+*${meta.sampleSize} rows \xB7 Source: ${meta.source} \xB7 Season ${meta.season}*`;
+  return {
+    raw: data,
+    formatted: [header, separator, ...rows, footer].join("\n") + "\n",
+    meta
+  };
+}
+function formatMdCell(value) {
+  if (value === null || value === void 0) return "\u2014";
+  if (typeof value === "number") {
+    if (Math.abs(value) <= 1 && value !== 0) return (value * 100).toFixed(1) + "%";
+    if (Number.isInteger(value)) return String(value);
+    return value.toFixed(1);
+  }
+  return String(value);
+}
+
+// src/formatters/index.ts
+function format(data, meta, outputFormat, options) {
+  switch (outputFormat) {
+    case "json":
+      return formatJson(data, meta);
+    case "table":
+      return formatTable(data, meta, options);
+    case "csv":
+      return formatCsv(data, meta);
+    case "markdown":
+      return formatMarkdown(data, meta);
+  }
+}
+
+// src/config/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/config/defaults.ts
+import { z } from "zod";
+var ConfigSchema = z.object({
+  defaultTeam: z.string().optional(),
+  defaultFormat: z.enum(["json", "table", "csv", "markdown"]).default("json"),
+  defaultAudience: z.enum(["coach", "gm", "scout", "analyst"]).default("analyst"),
+  cache: z.object({
+    enabled: z.boolean().default(true),
+    maxAgeDays: z.number().default(30),
+    directory: z.string().default("")
+  }).default({}),
+  templates: z.object({
+    directory: z.string().default("")
+  }).default({}),
+  sources: z.object({
+    savant: z.object({ enabled: z.boolean().default(true) }).default({}),
+    fangraphs: z.object({ enabled: z.boolean().default(true) }).default({}),
+    mlbStatsApi: z.object({ enabled: z.boolean().default(true) }).default({}),
+    baseballReference: z.object({ enabled: z.boolean().default(false) }).default({})
+  }).default({})
+});
+function getDefaultConfig() {
+  return ConfigSchema.parse({});
+}
+
+// src/config/config.ts
+var BBDATA_DIR = join(homedir(), ".bbdata");
+var CONFIG_PATH = join(BBDATA_DIR, "config.json");
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function getConfig() {
+  ensureDir(BBDATA_DIR);
+  if (!existsSync(CONFIG_PATH)) {
+    const defaults = getDefaultConfig();
+    writeFileSync(CONFIG_PATH, JSON.stringify(defaults, null, 2), "utf-8");
+    return defaults;
+  }
+  try {
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    return ConfigSchema.parse(raw);
+  } catch {
+    return getDefaultConfig();
+  }
+}
+function setConfig(updates) {
+  const current = getConfig();
+  const merged = { ...current, ...updates };
+  const validated = ConfigSchema.parse(merged);
+  ensureDir(BBDATA_DIR);
+  writeFileSync(CONFIG_PATH, JSON.stringify(validated, null, 2), "utf-8");
+  return validated;
+}
+function getTemplatesDir() {
+  const config = getConfig();
+  const dir = config.templates.directory || join(BBDATA_DIR, "templates");
+  ensureDir(dir);
+  return dir;
+}
+
+// src/templates/queries/registry.ts
+var templates = /* @__PURE__ */ new Map();
+function registerTemplate(template13) {
+  templates.set(template13.id, template13);
+}
+function getTemplate(id) {
+  return templates.get(id);
+}
+function getAllTemplates() {
+  return Array.from(templates.values());
+}
+function listTemplates() {
+  return getAllTemplates().map((t) => ({
+    id: t.id,
+    name: t.name,
+    category: t.category,
+    description: t.description
+  }));
+}
+
+// src/adapters/types.ts
+import { z as z2 } from "zod";
+var PitchDataSchema = z2.object({
+  pitcher_id: z2.string(),
+  pitcher_name: z2.string(),
+  batter_id: z2.string(),
+  batter_name: z2.string(),
+  game_date: z2.string(),
+  pitch_type: z2.string(),
+  // FF, SL, CH, CU, SI, FC, KC, FS, etc.
+  release_speed: z2.number(),
+  // mph
+  release_spin_rate: z2.number(),
+  // rpm
+  pfx_x: z2.number(),
+  // horizontal movement (inches)
+  pfx_z: z2.number(),
+  // vertical movement (inches)
+  plate_x: z2.number(),
+  // horizontal location
+  plate_z: z2.number(),
+  // vertical location
+  launch_speed: z2.number().nullable(),
+  // exit velocity (mph)
+  launch_angle: z2.number().nullable(),
+  // degrees
+  description: z2.string(),
+  // called_strike, swinging_strike, ball, foul, hit_into_play, etc.
+  events: z2.string().nullable(),
+  // single, double, home_run, strikeout, etc.
+  bb_type: z2.string().nullable(),
+  // fly_ball, ground_ball, line_drive, popup
+  stand: z2.enum(["L", "R"]),
+  // batter handedness
+  p_throws: z2.enum(["L", "R"]),
+  // pitcher handedness
+  estimated_ba: z2.number().nullable(),
+  // xBA
+  estimated_woba: z2.number().nullable()
+  // xwOBA
+});
+var PlayerStatsSchema = z2.object({
+  player_id: z2.string(),
+  player_name: z2.string(),
+  team: z2.string(),
+  season: z2.number(),
+  stat_type: z2.enum(["batting", "pitching", "fielding"]),
+  stats: z2.record(z2.union([z2.number(), z2.string(), z2.null()]))
+});
+var PITCH_TYPE_MAP = {
+  FF: "Four-Seam Fastball",
+  SI: "Sinker",
+  FC: "Cutter",
+  SL: "Slider",
+  CU: "Curveball",
+  KC: "Knuckle Curve",
+  CH: "Changeup",
+  FS: "Splitter",
+  KN: "Knuckleball",
+  EP: "Eephus",
+  SC: "Screwball",
+  ST: "Sweeper",
+  SV: "Slurve"
+};
+function pitchTypeName(code) {
+  return PITCH_TYPE_MAP[code.toUpperCase()] ?? code;
+}
+
+// src/templates/queries/pitcher-arsenal.ts
+var template = {
+  id: "pitcher-arsenal",
+  name: "Pitcher Arsenal Profile",
+  category: "pitcher",
+  description: "Pitch usage rates, velocity, spin, movement, and whiff rates by pitch type",
+  preferredSources: ["savant", "fangraphs", "mlb-stats-api"],
+  requiredParams: ["player"],
+  optionalParams: ["season", "pitchType"],
+  examples: [
+    'bbdata query pitcher-arsenal --player "Corbin Burnes" --season 2025',
+    'bbdata query pitcher-arsenal --player "Spencer Strider"'
+  ],
+  buildQuery(params) {
+    return {
+      player_name: params.player,
+      season: params.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+      stat_type: "pitching",
+      pitch_type: params.pitchType ? [params.pitchType] : void 0
+    };
+  },
+  columns() {
+    return [
+      "Pitch Type",
+      "Usage %",
+      "Avg Velo",
+      "Avg Spin",
+      "H Break",
+      "V Break",
+      "Whiff %",
+      "Put Away %",
+      "Pitches"
+    ];
+  },
+  transform(data, _params) {
+    const pitches = data;
+    if (pitches.length === 0) return [];
+    const byType = /* @__PURE__ */ new Map();
+    for (const pitch of pitches) {
+      if (!pitch.pitch_type) continue;
+      const group = byType.get(pitch.pitch_type) ?? [];
+      group.push(pitch);
+      byType.set(pitch.pitch_type, group);
+    }
+    const total = pitches.length;
+    return Array.from(byType.entries()).map(([type, group]) => {
+      const count = group.length;
+      const swings = group.filter(
+        (p) => p.description.includes("swing") || p.description.includes("foul")
+      );
+      const whiffs = group.filter(
+        (p) => p.description.includes("swinging_strike")
+      );
+      const twoStrikes = group.filter(
+        (p) => p.description.includes("strikeout") || p.description.includes("swinging_strike")
+      );
+      return {
+        "Pitch Type": pitchTypeName(type),
+        "Usage %": (count / total * 100).toFixed(1) + "%",
+        "Avg Velo": (group.reduce((s, p) => s + p.release_speed, 0) / count).toFixed(1) + " mph",
+        "Avg Spin": Math.round(group.reduce((s, p) => s + p.release_spin_rate, 0) / count) + " rpm",
+        "H Break": (group.reduce((s, p) => s + p.pfx_x, 0) / count).toFixed(1) + " in",
+        "V Break": (group.reduce((s, p) => s + p.pfx_z, 0) / count).toFixed(1) + " in",
+        "Whiff %": swings.length > 0 ? (whiffs.length / swings.length * 100).toFixed(1) + "%" : "\u2014",
+        "Put Away %": twoStrikes.length > 0 ? (whiffs.length / count * 100).toFixed(1) + "%" : "\u2014",
+        "Pitches": count
+      };
+    }).sort((a, b) => b.Pitches - a.Pitches);
+  }
+};
+registerTemplate(template);
+
+// src/templates/queries/pitcher-velocity-trend.ts
+var template2 = {
+  id: "pitcher-velocity-trend",
+  name: "Pitcher Velocity Trend",
+  category: "pitcher",
+  description: "Month-by-month fastball velocity tracking \u2014 flags drops > 0.5 mph",
+  preferredSources: ["savant"],
+  requiredParams: ["player"],
+  optionalParams: ["season"],
+  examples: [
+    'bbdata query pitcher-velocity-trend --player "Gerrit Cole" --season 2025'
+  ],
+  buildQuery(params) {
+    return {
+      player_name: params.player,
+      season: params.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+      stat_type: "pitching"
+    };
+  },
+  columns() {
+    return ["Month", "Avg Velo", "Max Velo", "Min Velo", "\u0394 vs Prior", "Pitches", "Flag"];
+  },
+  transform(data) {
+    const pitches = data.filter(
+      (p) => ["FF", "SI", "FC"].includes(p.pitch_type) && p.release_speed > 0
+    );
+    if (pitches.length === 0) return [];
+    const byMonth = /* @__PURE__ */ new Map();
+    for (const pitch of pitches) {
+      const month = pitch.game_date.slice(0, 7);
+      const group = byMonth.get(month) ?? [];
+      group.push(pitch);
+      byMonth.set(month, group);
+    }
+    const months = Array.from(byMonth.entries()).sort(([a], [b]) => a.localeCompare(b));
+    let prevAvg = null;
+    return months.map(([month, group]) => {
+      const velos = group.map((p) => p.release_speed);
+      const avg = velos.reduce((s, v) => s + v, 0) / velos.length;
+      const max = Math.max(...velos);
+      const min = Math.min(...velos);
+      const delta = prevAvg !== null ? avg - prevAvg : 0;
+      const flag = prevAvg !== null && delta < -0.5 ? "\u26A0 DROP" : "";
+      prevAvg = avg;
+      return {
+        Month: month,
+        "Avg Velo": avg.toFixed(1) + " mph",
+        "Max Velo": max.toFixed(1) + " mph",
+        "Min Velo": min.toFixed(1) + " mph",
+        "\u0394 vs Prior": prevAvg !== null && delta !== 0 ? (delta > 0 ? "+" : "") + delta.toFixed(1) + " mph" : "\u2014",
+        Pitches: group.length,
+        Flag: flag
+      };
+    });
+  }
+};
+registerTemplate(template2);
+
+// src/templates/queries/pitcher-handedness-splits.ts
+var template3 = {
+  id: "pitcher-handedness-splits",
+  name: "Pitcher Handedness Splits",
+  category: "pitcher",
+  description: "Performance splits vs LHH and RHH \u2014 BA, SLG, K%, BB%, pitch mix, exit velocity",
+  preferredSources: ["savant", "fangraphs"],
+  requiredParams: ["player"],
+  optionalParams: ["season"],
+  examples: [
+    'bbdata query pitcher-handedness-splits --player "Blake Snell" --season 2025'
+  ],
+  buildQuery(params) {
+    return {
+      player_name: params.player,
+      season: params.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+      stat_type: "pitching"
+    };
+  },
+  columns() {
+    return ["vs", "PA", "AVG", "SLG", "K %", "BB %", "Avg EV", "Whiff %"];
+  },
+  transform(data) {
+    const pitches = data;
+    if (pitches.length === 0) return [];
+    return ["L", "R"].map((hand) => {
+      const group = pitches.filter((p) => p.stand === hand);
+      if (group.length === 0) {
+        return { vs: `vs ${hand}HH`, PA: 0, AVG: "\u2014", SLG: "\u2014", "K %": "\u2014", "BB %": "\u2014", "Avg EV": "\u2014", "Whiff %": "\u2014" };
+      }
+      const pas = group.filter((p) => p.events !== null);
+      const hits = pas.filter(
+        (p) => ["single", "double", "triple", "home_run"].includes(p.events ?? "")
+      );
+      const strikeouts = pas.filter((p) => p.events === "strikeout");
+      const walks = pas.filter((p) => ["walk", "hit_by_pitch"].includes(p.events ?? ""));
+      const contacted = group.filter((p) => p.launch_speed !== null && p.launch_speed > 0);
+      const avgEv = contacted.length > 0 ? contacted.reduce((s, p) => s + (p.launch_speed ?? 0), 0) / contacted.length : null;
+      const totalBases = pas.reduce((sum, p) => {
+        if (p.events === "single") return sum + 1;
+        if (p.events === "double") return sum + 2;
+        if (p.events === "triple") return sum + 3;
+        if (p.events === "home_run") return sum + 4;
+        return sum;
+      }, 0);
+      const swings = group.filter(
+        (p) => p.description.includes("swing") || p.description.includes("foul")
+      );
+      const whiffs = group.filter((p) => p.description.includes("swinging_strike"));
+      return {
+        vs: `vs ${hand}HH`,
+        PA: pas.length,
+        AVG: pas.length > 0 ? (hits.length / pas.length).toFixed(3) : "\u2014",
+        SLG: pas.length > 0 ? (totalBases / pas.length).toFixed(3) : "\u2014",
+        "K %": pas.length > 0 ? (strikeouts.length / pas.length * 100).toFixed(1) + "%" : "\u2014",
+        "BB %": pas.length > 0 ? (walks.length / pas.length * 100).toFixed(1) + "%" : "\u2014",
+        "Avg EV": avgEv !== null ? avgEv.toFixed(1) + " mph" : "\u2014",
+        "Whiff %": swings.length > 0 ? (whiffs.length / swings.length * 100).toFixed(1) + "%" : "\u2014"
+      };
+    });
+  }
+};
+registerTemplate(template3);
+
+// src/templates/queries/hitter-batted-ball.ts
+var template4 = {
+  id: "hitter-batted-ball",
+  name: "Hitter Batted Ball Profile",
+  category: "hitter",
+  description: "Exit velocity, launch angle, hard hit rate, barrel rate, batted ball distribution",
+  preferredSources: ["savant", "fangraphs"],
+  requiredParams: ["player"],
+  optionalParams: ["season"],
+  examples: [
+    'bbdata query hitter-batted-ball --player "Aaron Judge" --season 2025',
+    'bbdata query hitter-batted-ball --player "Juan Soto"'
+  ],
+  buildQuery(params) {
+    return {
+      player_name: params.player,
+      season: params.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+      stat_type: "batting"
+    };
+  },
+  columns() {
+    return ["Metric", "Value"];
+  },
+  transform(data) {
+    const pitches = data;
+    const batted = pitches.filter((p) => p.launch_speed !== null && p.launch_speed > 0);
+    if (batted.length === 0) return [];
+    const evs = batted.map((p) => p.launch_speed);
+    const las = batted.map((p) => p.launch_angle);
+    const avgEv = evs.reduce((s, v) => s + v, 0) / evs.length;
+    const avgLa = las.reduce((s, v) => s + v, 0) / las.length;
+    const hardHit = batted.filter((p) => p.launch_speed >= 95).length;
+    const barrels = batted.filter(
+      (p) => p.launch_speed >= 98 && p.launch_angle >= 26 && p.launch_angle <= 30
+    ).length;
+    const linedrives = batted.filter((p) => p.bb_type === "line_drive").length;
+    const flyballs = batted.filter((p) => p.bb_type === "fly_ball").length;
+    const groundballs = batted.filter((p) => p.bb_type === "ground_ball").length;
+    const popups = batted.filter((p) => p.bb_type === "popup").length;
+    return [
+      { Metric: "Batted Balls", Value: batted.length },
+      { Metric: "Avg Exit Velocity", Value: avgEv.toFixed(1) + " mph" },
+      { Metric: "Max Exit Velocity", Value: Math.max(...evs).toFixed(1) + " mph" },
+      { Metric: "Avg Launch Angle", Value: avgLa.toFixed(1) + "\xB0" },
+      { Metric: "Hard Hit Rate (95+ mph)", Value: (hardHit / batted.length * 100).toFixed(1) + "%" },
+      { Metric: "Barrel Rate", Value: (barrels / batted.length * 100).toFixed(1) + "%" },
+      { Metric: "Line Drive %", Value: (linedrives / batted.length * 100).toFixed(1) + "%" },
+      { Metric: "Fly Ball %", Value: (flyballs / batted.length * 100).toFixed(1) + "%" },
+      { Metric: "Ground Ball %", Value: (groundballs / batted.length * 100).toFixed(1) + "%" },
+      { Metric: "Popup %", Value: (popups / batted.length * 100).toFixed(1) + "%" }
+    ];
+  }
+};
+registerTemplate(template4);
+
+// src/templates/queries/hitter-vs-pitch-type.ts
+var template5 = {
+  id: "hitter-vs-pitch-type",
+  name: "Hitter vs Pitch Type",
+  category: "hitter",
+  description: "Swing rate, whiff rate, exit velocity, and outcomes by pitch type faced",
+  preferredSources: ["savant"],
+  requiredParams: ["player"],
+  optionalParams: ["season"],
+  examples: [
+    'bbdata query hitter-vs-pitch-type --player "Mookie Betts" --season 2025'
+  ],
+  buildQuery(params) {
+    return {
+      player_name: params.player,
+      season: params.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+      stat_type: "batting"
+    };
+  },
+  columns() {
+    return ["Pitch Type", "Seen", "Swing %", "Whiff %", "Foul %", "In Play", "Avg EV", "SLG"];
+  },
+  transform(data) {
+    const pitches = data;
+    if (pitches.length === 0) return [];
+    const byType = /* @__PURE__ */ new Map();
+    for (const p of pitches) {
+      if (!p.pitch_type) continue;
+      const group = byType.get(p.pitch_type) ?? [];
+      group.push(p);
+      byType.set(p.pitch_type, group);
+    }
+    return Array.from(byType.entries()).map(([type, group]) => {
+      const swings = group.filter(
+        (p) => p.description.includes("swing") || p.description.includes("foul") || p.description.includes("hit_into_play")
+      );
+      const whiffs = group.filter((p) => p.description.includes("swinging_strike"));
+      const fouls = group.filter((p) => p.description.includes("foul"));
+      const inPlay = group.filter((p) => p.description.includes("hit_into_play"));
+      const contacted = group.filter((p) => p.launch_speed !== null && p.launch_speed > 0);
+      const totalBases = group.reduce((sum, p) => {
+        if (p.events === "single") return sum + 1;
+        if (p.events === "double") return sum + 2;
+        if (p.events === "triple") return sum + 3;
+        if (p.events === "home_run") return sum + 4;
+        return sum;
+      }, 0);
+      const abs = group.filter((p) => p.events && !["walk", "hit_by_pitch", "sac_fly", "sac_bunt"].includes(p.events)).length;
+      return {
+        "Pitch Type": pitchTypeName(type),
+        Seen: group.length,
+        "Swing %": (swings.length / group.length * 100).toFixed(1) + "%",
+        "Whiff %": swings.length > 0 ? (whiffs.length / swings.length * 100).toFixed(1) + "%" : "\u2014",
+        "Foul %": swings.length > 0 ? (fouls.length / swings.length * 100).toFixed(1) + "%" : "\u2014",
+        "In Play": inPlay.length,
+        "Avg EV": contacted.length > 0 ? (contacted.reduce((s, p) => s + p.launch_speed, 0) / contacted.length).toFixed(1) + " mph" : "\u2014",
+        SLG: abs > 0 ? (totalBases / abs).toFixed(3) : "\u2014"
+      };
+    }).sort((a, b) => b.Seen - a.Seen);
+  }
+};
+registerTemplate(template5);
+
+// src/templates/queries/hitter-hot-cold-zones.ts
+var ZONES = {
+  "High-In": { xMin: -0.83, xMax: -0.28, zMin: 2.83, zMax: 3.5 },
+  "High-Mid": { xMin: -0.28, xMax: 0.28, zMin: 2.83, zMax: 3.5 },
+  "High-Out": { xMin: 0.28, xMax: 0.83, zMin: 2.83, zMax: 3.5 },
+  "Mid-In": { xMin: -0.83, xMax: -0.28, zMin: 2.17, zMax: 2.83 },
+  "Mid-Mid": { xMin: -0.28, xMax: 0.28, zMin: 2.17, zMax: 2.83 },
+  "Mid-Out": { xMin: 0.28, xMax: 0.83, zMin: 2.17, zMax: 2.83 },
+  "Low-In": { xMin: -0.83, xMax: -0.28, zMin: 1.5, zMax: 2.17 },
+  "Low-Mid": { xMin: -0.28, xMax: 0.28, zMin: 1.5, zMax: 2.17 },
+  "Low-Out": { xMin: 0.28, xMax: 0.83, zMin: 1.5, zMax: 2.17 }
+};
+var template6 = {
+  id: "hitter-hot-cold-zones",
+  name: "Hitter Hot/Cold Zones",
+  category: "hitter",
+  description: "3x3 strike zone grid with BA, SLG, whiff rate, and pitch count per zone",
+  preferredSources: ["savant"],
+  requiredParams: ["player"],
+  optionalParams: ["season"],
+  examples: [
+    'bbdata query hitter-hot-cold-zones --player "Shohei Ohtani" --season 2025'
+  ],
+  buildQuery(params) {
+    return {
+      player_name: params.player,
+      season: params.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+      stat_type: "batting"
+    };
+  },
+  columns() {
+    return ["Zone", "Pitches", "Swings", "Whiff %", "AVG", "SLG"];
+  },
+  transform(data) {
+    const pitches = data;
+    if (pitches.length === 0) return [];
+    return Object.entries(ZONES).map(([zoneName, bounds]) => {
+      const inZone = pitches.filter(
+        (p) => p.plate_x >= bounds.xMin && p.plate_x < bounds.xMax && p.plate_z >= bounds.zMin && p.plate_z < bounds.zMax
+      );
+      const swings = inZone.filter(
+        (p) => p.description.includes("swing") || p.description.includes("foul") || p.description.includes("hit_into_play")
+      );
+      const whiffs = inZone.filter((p) => p.description.includes("swinging_strike"));
+      const abs = inZone.filter((p) => p.events && !["walk", "hit_by_pitch"].includes(p.events));
+      const hits = abs.filter(
+        (p) => ["single", "double", "triple", "home_run"].includes(p.events ?? "")
+      );
+      const totalBases = abs.reduce((sum, p) => {
+        if (p.events === "single") return sum + 1;
+        if (p.events === "double") return sum + 2;
+        if (p.events === "triple") return sum + 3;
+        if (p.events === "home_run") return sum + 4;
+        return sum;
+      }, 0);
+      return {
+        Zone: zoneName,
+        Pitches: inZone.length,
+        Swings: swings.length,
+        "Whiff %": swings.length > 0 ? (whiffs.length / swings.length * 100).toFixed(1) + "%" : "\u2014",
+        AVG: abs.length > 0 ? (hits.length / abs.length).toFixed(3) : "\u2014",
+        SLG: abs.length > 0 ? (totalBases / abs.length).toFixed(3) : "\u2014"
+      };
+    });
+  }
+};
+registerTemplate(template6);
+
+// src/templates/queries/matchup-pitcher-vs-hitter.ts
+var template7 = {
+  id: "matchup-pitcher-vs-hitter",
+  name: "Pitcher vs Hitter Matchup",
+  category: "matchup",
+  description: "Career head-to-head history \u2014 PA, H, HR, BB, K, BA, SLG, most common pitches",
+  preferredSources: ["savant"],
+  requiredParams: ["players"],
+  // expects [pitcher, hitter]
+  optionalParams: ["season"],
+  examples: [
+    'bbdata query matchup-pitcher-vs-hitter --players "Gerrit Cole,Aaron Judge"'
+  ],
+  buildQuery(params) {
+    return {
+      player_name: params.players?.[0],
+      season: params.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+      stat_type: "pitching"
+    };
+  },
+  columns() {
+    return ["Metric", "Value"];
+  },
+  transform(data, params) {
+    const pitches = data;
+    const hitterName = (params.players?.[1] ?? "").toLowerCase();
+    const matchup = pitches.filter(
+      (p) => p.batter_name.toLowerCase().includes(hitterName)
+    );
+    if (matchup.length === 0) {
+      return [{ Metric: "Note", Value: `No matchup data found for ${params.players?.[1] ?? "hitter"}` }];
+    }
+    const pas = matchup.filter((p) => p.events !== null);
+    const hits = pas.filter((p) => ["single", "double", "triple", "home_run"].includes(p.events ?? ""));
+    const hrs = pas.filter((p) => p.events === "home_run");
+    const ks = pas.filter((p) => p.events === "strikeout");
+    const bbs = pas.filter((p) => ["walk", "hit_by_pitch"].includes(p.events ?? ""));
+    const totalBases = pas.reduce((sum, p) => {
+      if (p.events === "single") return sum + 1;
+      if (p.events === "double") return sum + 2;
+      if (p.events === "triple") return sum + 3;
+      if (p.events === "home_run") return sum + 4;
+      return sum;
+    }, 0);
+    const pitchCounts = /* @__PURE__ */ new Map();
+    for (const p of matchup) {
+      pitchCounts.set(p.pitch_type, (pitchCounts.get(p.pitch_type) ?? 0) + 1);
+    }
+    const topPitches = Array.from(pitchCounts.entries()).sort(([, a], [, b]) => b - a).slice(0, 3).map(([type, count]) => `${pitchTypeName(type)} (${count})`).join(", ");
+    return [
+      { Metric: "Total Pitches", Value: matchup.length },
+      { Metric: "Plate Appearances", Value: pas.length },
+      { Metric: "Hits", Value: hits.length },
+      { Metric: "Home Runs", Value: hrs.length },
+      { Metric: "Strikeouts", Value: ks.length },
+      { Metric: "Walks", Value: bbs.length },
+      { Metric: "AVG", Value: pas.length > 0 ? (hits.length / pas.length).toFixed(3) : "\u2014" },
+      { Metric: "SLG", Value: pas.length > 0 ? (totalBases / pas.length).toFixed(3) : "\u2014" },
+      { Metric: "Most Common Pitches", Value: topPitches }
+    ];
+  }
+};
+registerTemplate(template7);
+
+// src/templates/queries/matchup-situational.ts
+var template8 = {
+  id: "matchup-situational",
+  name: "Situational Splits",
+  category: "matchup",
+  description: "Performance in key situations \u2014 RISP, high leverage, close & late, by inning",
+  preferredSources: ["fangraphs", "mlb-stats-api"],
+  requiredParams: ["player"],
+  optionalParams: ["season"],
+  examples: [
+    'bbdata query matchup-situational --player "Juan Soto" --season 2025'
+  ],
+  buildQuery(params) {
+    return {
+      player_name: params.player,
+      season: params.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+      stat_type: "batting"
+    };
+  },
+  columns() {
+    return ["Situation", "PA", "AVG", "OBP", "SLG", "K %", "BB %"];
+  },
+  transform(data) {
+    const stats = data;
+    if (stats.length === 0) return [];
+    const player = stats[0];
+    const s = player.stats;
+    return [
+      {
+        Situation: "Overall",
+        PA: s.plateAppearances ?? s.PA ?? "\u2014",
+        AVG: formatStat(s.avg ?? s.AVG),
+        OBP: formatStat(s.obp ?? s.OBP),
+        SLG: formatStat(s.slg ?? s.SLG),
+        "K %": formatPct(s.strikeOuts ?? s.SO, s.plateAppearances ?? s.PA),
+        "BB %": formatPct(s.baseOnBalls ?? s.BB, s.plateAppearances ?? s.PA)
+      }
+    ];
+  }
+};
+function formatStat(val) {
+  if (val === null || val === void 0) return "\u2014";
+  const n = Number(val);
+  if (isNaN(n)) return String(val);
+  return n < 1 ? n.toFixed(3) : n.toFixed(1);
+}
+function formatPct(num, denom) {
+  const n = Number(num);
+  const d = Number(denom);
+  if (isNaN(n) || isNaN(d) || d === 0) return "\u2014";
+  return (n / d * 100).toFixed(1) + "%";
+}
+registerTemplate(template8);
+
+// src/templates/queries/leaderboard-custom.ts
+var template9 = {
+  id: "leaderboard-custom",
+  name: "Custom Leaderboard",
+  category: "leaderboard",
+  description: "Top N players by any metric \u2014 with minimum qualification thresholds",
+  preferredSources: ["fangraphs", "mlb-stats-api"],
+  requiredParams: ["stat"],
+  optionalParams: ["season", "team", "top", "minPa", "minIp"],
+  examples: [
+    "bbdata query leaderboard-custom --stat barrel_rate --min-pa 200 --top 20",
+    "bbdata query leaderboard-custom --stat ERA --min-ip 100 --top 10 --format table"
+  ],
+  buildQuery(params) {
+    return {
+      season: params.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+      team: params.team,
+      stat_type: "batting",
+      // Will be overridden based on stat
+      min_pa: params.minPa,
+      min_ip: params.minIp
+    };
+  },
+  columns(params) {
+    return ["Rank", "Player", "Team", params.stat ?? "Stat", "PA/IP"];
+  },
+  transform(data, params) {
+    const stats = data;
+    if (stats.length === 0) return [];
+    const statKey = params.stat ?? "";
+    const top = params.top ?? 20;
+    const withStat = stats.map((player) => {
+      const value = findStat(player.stats, statKey);
+      return { player, value };
+    }).filter((p) => p.value !== null).sort((a, b) => {
+      const ascending = ["era", "fip", "xfip", "siera", "whip", "bb%"].includes(
+        statKey.toLowerCase()
+      );
+      return ascending ? a.value - b.value : b.value - a.value;
+    }).slice(0, top);
+    return withStat.map((entry, idx) => ({
+      Rank: idx + 1,
+      Player: entry.player.player_name,
+      Team: entry.player.team,
+      [statKey]: typeof entry.value === "number" ? entry.value < 1 && entry.value > 0 ? entry.value.toFixed(3) : entry.value.toFixed(1) : String(entry.value),
+      "PA/IP": entry.player.stats.plateAppearances ?? entry.player.stats.PA ?? entry.player.stats.inningsPitched ?? entry.player.stats.IP ?? "\u2014"
+    }));
+  }
+};
+function findStat(stats, key) {
+  if (key in stats) {
+    const val = Number(stats[key]);
+    return isNaN(val) ? null : val;
+  }
+  const lower = key.toLowerCase();
+  for (const [k, v] of Object.entries(stats)) {
+    if (k.toLowerCase() === lower || k.toLowerCase().replace(/[_%]/g, "") === lower.replace(/[_%]/g, "")) {
+      const val = Number(v);
+      return isNaN(val) ? null : val;
+    }
+  }
+  return null;
+}
+registerTemplate(template9);
+
+// src/templates/queries/leaderboard-comparison.ts
+var template10 = {
+  id: "leaderboard-comparison",
+  name: "Player Comparison",
+  category: "leaderboard",
+  description: "Side-by-side comparison of multiple players across key metrics vs league average",
+  preferredSources: ["fangraphs", "mlb-stats-api"],
+  requiredParams: ["players"],
+  optionalParams: ["season"],
+  examples: [
+    'bbdata query leaderboard-comparison --players "Aaron Judge,Juan Soto,Mookie Betts"'
+  ],
+  buildQuery(params) {
+    return {
+      season: params.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+      stat_type: "batting"
+    };
+  },
+  columns(params) {
+    return ["Metric", ...params.players ?? []];
+  },
+  transform(data, params) {
+    const allStats = data;
+    const playerNames = params.players ?? [];
+    const matched = playerNames.map((name) => {
+      const norm = name.toLowerCase();
+      return allStats.find((s) => s.player_name.toLowerCase().includes(norm));
+    });
+    const metrics = [
+      "AVG",
+      "OBP",
+      "SLG",
+      "OPS",
+      "wRC+",
+      "WAR",
+      "HR",
+      "RBI",
+      "K%",
+      "BB%",
+      "ISO",
+      "BABIP"
+    ];
+    return metrics.map((metric) => {
+      const row = { Metric: metric };
+      for (let i = 0; i < playerNames.length; i++) {
+        const player = matched[i];
+        if (!player) {
+          row[playerNames[i]] = "\u2014";
+          continue;
+        }
+        const val = findStatValue(player.stats, metric);
+        row[playerNames[i]] = val ?? "\u2014";
+      }
+      return row;
+    });
+  }
+};
+function findStatValue(stats, key) {
+  const lower = key.toLowerCase().replace(/[+%]/g, "");
+  for (const [k, v] of Object.entries(stats)) {
+    if (k.toLowerCase().replace(/[+%]/g, "") === lower) {
+      if (v === null || v === void 0) return null;
+      const n = Number(v);
+      if (isNaN(n)) return String(v);
+      return n < 1 && n > 0 ? n.toFixed(3) : n % 1 === 0 ? String(n) : n.toFixed(1);
+    }
+  }
+  return null;
+}
+registerTemplate(template10);
+
+// src/templates/queries/trend-rolling-average.ts
+var template11 = {
+  id: "trend-rolling-average",
+  name: "Season Trend (Rolling Average)",
+  category: "trend",
+  description: "15-game (hitters) or 5-start (pitchers) rolling averages \u2014 identifies sustained trends",
+  preferredSources: ["savant"],
+  requiredParams: ["player"],
+  optionalParams: ["season"],
+  examples: [
+    'bbdata query trend-rolling-average --player "Freddie Freeman" --season 2025'
+  ],
+  buildQuery(params) {
+    return {
+      player_name: params.player,
+      season: params.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+      stat_type: "batting"
+    };
+  },
+  columns() {
+    return ["Window", "Games", "AVG", "SLG", "K %", "Avg EV", "Hard Hit %"];
+  },
+  transform(data) {
+    const pitches = data;
+    if (pitches.length === 0) return [];
+    const byDate = /* @__PURE__ */ new Map();
+    for (const p of pitches) {
+      const group = byDate.get(p.game_date) ?? [];
+      group.push(p);
+      byDate.set(p.game_date, group);
+    }
+    const dates = Array.from(byDate.keys()).sort();
+    const windowSize = 15;
+    if (dates.length < windowSize) {
+      return [{ Window: "Insufficient data", Games: dates.length, AVG: "\u2014", SLG: "\u2014", "K %": "\u2014", "Avg EV": "\u2014", "Hard Hit %": "\u2014" }];
+    }
+    const results = [];
+    for (let i = 0; i <= dates.length - windowSize; i += Math.max(1, Math.floor(windowSize / 3))) {
+      const windowDates = dates.slice(i, i + windowSize);
+      const windowPitches = windowDates.flatMap((d) => byDate.get(d) ?? []);
+      const pas = windowPitches.filter((p) => p.events !== null);
+      const hits = pas.filter((p) => ["single", "double", "triple", "home_run"].includes(p.events ?? ""));
+      const ks = pas.filter((p) => p.events === "strikeout");
+      const totalBases = pas.reduce((sum, p) => {
+        if (p.events === "single") return sum + 1;
+        if (p.events === "double") return sum + 2;
+        if (p.events === "triple") return sum + 3;
+        if (p.events === "home_run") return sum + 4;
+        return sum;
+      }, 0);
+      const batted = windowPitches.filter((p) => p.launch_speed !== null && p.launch_speed > 0);
+      const avgEv = batted.length > 0 ? batted.reduce((s, p) => s + p.launch_speed, 0) / batted.length : null;
+      const hardHit = batted.filter((p) => p.launch_speed >= 95).length;
+      results.push({
+        Window: `${windowDates[0]} \u2192 ${windowDates[windowDates.length - 1]}`,
+        Games: windowDates.length,
+        AVG: pas.length > 0 ? (hits.length / pas.length).toFixed(3) : "\u2014",
+        SLG: pas.length > 0 ? (totalBases / pas.length).toFixed(3) : "\u2014",
+        "K %": pas.length > 0 ? (ks.length / pas.length * 100).toFixed(1) + "%" : "\u2014",
+        "Avg EV": avgEv !== null ? avgEv.toFixed(1) + " mph" : "\u2014",
+        "Hard Hit %": batted.length > 0 ? (hardHit / batted.length * 100).toFixed(1) + "%" : "\u2014"
+      });
+    }
+    return results;
+  }
+};
+registerTemplate(template11);
+
+// src/templates/queries/trend-year-over-year.ts
+var template12 = {
+  id: "trend-year-over-year",
+  name: "Year-over-Year Comparison",
+  category: "trend",
+  description: "Compare metric changes year to year \u2014 flags changes greater than 10%",
+  preferredSources: ["fangraphs", "mlb-stats-api"],
+  requiredParams: ["player"],
+  optionalParams: ["seasons"],
+  // e.g. "2023-2025"
+  examples: [
+    'bbdata query trend-year-over-year --player "Julio Rodriguez" --seasons 2023-2025'
+  ],
+  buildQuery(params) {
+    const season = params.season ?? (/* @__PURE__ */ new Date()).getFullYear();
+    return {
+      player_name: params.player,
+      season,
+      stat_type: "batting"
+    };
+  },
+  columns() {
+    return ["Metric", "Prior", "Current", "Change", "Flag"];
+  },
+  transform(data, params) {
+    const stats = data;
+    if (stats.length === 0) return [];
+    const player = stats[0];
+    const s = player.stats;
+    const metrics = ["AVG", "OBP", "SLG", "HR", "wRC+", "K%", "BB%", "WAR", "ISO", "BABIP"];
+    return metrics.map((metric) => {
+      const current = findStat2(s, metric);
+      return {
+        Metric: metric,
+        Prior: "\u2014",
+        Current: current !== null ? formatVal(current) : "\u2014",
+        Change: "\u2014",
+        Flag: ""
+      };
+    });
+  }
+};
+function findStat2(stats, key) {
+  const lower = key.toLowerCase().replace(/[+%]/g, "");
+  for (const [k, v] of Object.entries(stats)) {
+    if (k.toLowerCase().replace(/[+%]/g, "") === lower) {
+      const n = Number(v);
+      return isNaN(n) ? null : n;
+    }
+  }
+  return null;
+}
+function formatVal(n) {
+  if (n < 1 && n > 0) return n.toFixed(3);
+  return n % 1 === 0 ? String(n) : n.toFixed(1);
+}
+registerTemplate(template12);
+
+// src/commands/query.ts
+async function query(options) {
+  const config = getConfig();
+  const outputFormat = options.format ?? config.defaultFormat;
+  const template13 = getTemplate(options.template);
+  if (!template13) {
+    const available = listTemplates().map((t) => `  ${t.id} \u2014 ${t.description}`).join("\n");
+    throw new Error(`Unknown template "${options.template}". Available templates:
+${available}`);
+  }
+  const params = {
+    player: options.player,
+    players: options.players?.split(",").map((s) => s.trim()),
+    team: options.team,
+    season: options.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+    stat: options.stat,
+    pitchType: options.pitchType,
+    minPa: options.minPa,
+    minIp: options.minIp,
+    top: options.top,
+    seasons: options.seasons
+  };
+  for (const req of template13.requiredParams) {
+    if (!params[req] && !(req === "players" && params.player)) {
+      throw new Error(`Template "${template13.id}" requires --${req}`);
+    }
+  }
+  const adapterQuery = template13.buildQuery(params);
+  const preferredSources = options.source ? [options.source] : template13.preferredSources;
+  const adapters2 = resolveAdapters(preferredSources);
+  let lastError;
+  let result;
+  const startTime = Date.now();
+  for (const adapter of adapters2) {
+    if (!adapter.supports(adapterQuery)) continue;
+    try {
+      log.info(`Querying ${adapter.source}...`);
+      const adapterResult = await adapter.fetch(adapterQuery, {
+        bypassCache: options.cache === false
+      });
+      const rows = template13.transform(adapterResult.data, params);
+      const columns = template13.columns(params);
+      result = {
+        rows,
+        columns,
+        title: template13.name,
+        description: template13.description,
+        source: adapter.source,
+        cached: adapterResult.cached
+      };
+      break;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      log.debug(`${adapter.source} failed: ${lastError.message}. Trying next source...`);
+    }
+  }
+  if (!result) {
+    throw lastError ?? new Error(`No adapter could fulfill this query`);
+  }
+  const queryTimeMs = Date.now() - startTime;
+  const output = format(result.rows, {
+    source: result.source,
+    cached: result.cached,
+    queryTimeMs,
+    season: params.season ?? (/* @__PURE__ */ new Date()).getFullYear(),
+    sampleSize: result.rows.length,
+    template: template13.id
+  }, outputFormat, { columns: result.columns });
+  return {
+    data: result.rows,
+    formatted: output.formatted,
+    meta: {
+      template: template13.id,
+      source: result.source,
+      cached: result.cached,
+      rowCount: result.rows.length,
+      season: params.season ?? (/* @__PURE__ */ new Date()).getFullYear()
+    }
+  };
+}
+
+// src/commands/report.ts
+import Handlebars from "handlebars";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/grading.ts
+import chalk3 from "chalk";
+function gradeLabel(grade) {
+  if (grade >= 70) return "Plus-Plus";
+  if (grade >= 60) return "Plus";
+  if (grade >= 55) return "Above Average";
+  if (grade >= 50) return "Average";
+  if (grade >= 45) return "Below Average";
+  if (grade >= 40) return "Fringe";
+  if (grade >= 30) return "Poor";
+  return "Non-existent";
+}
+function gradeColor(grade) {
+  if (grade >= 70) return chalk3.green.bold(String(grade));
+  if (grade >= 60) return chalk3.green(String(grade));
+  if (grade >= 55) return chalk3.cyan(String(grade));
+  if (grade >= 50) return chalk3.white(String(grade));
+  if (grade >= 45) return chalk3.yellow(String(grade));
+  if (grade >= 40) return chalk3.red(String(grade));
+  return chalk3.red.dim(String(grade));
+}
+function formatGrade(grade) {
+  return `${gradeColor(grade)} (${gradeLabel(grade)})`;
+}
+
+// src/templates/reports/registry.ts
+var templates2 = /* @__PURE__ */ new Map();
+function registerReportTemplate(template13) {
+  templates2.set(template13.id, template13);
+}
+function getReportTemplate(id) {
+  return templates2.get(id);
+}
+function getAllReportTemplates() {
+  return Array.from(templates2.values());
+}
+function listReportTemplates() {
+  return getAllReportTemplates().map((t) => ({
+    id: t.id,
+    name: t.name,
+    category: t.category,
+    description: t.description
+  }));
+}
+registerReportTemplate({
+  id: "pro-pitcher-eval",
+  name: "Pro Pitcher Evaluation",
+  category: "pro-scouting",
+  description: "Full MLB/MiLB pitcher assessment for trade/free agency decisions",
+  audiences: ["gm", "scout", "analyst"],
+  templateFile: "pro-pitcher-eval.hbs",
+  dataRequirements: [
+    { queryTemplate: "pitcher-arsenal", paramMapping: { player: "player" }, required: true },
+    { queryTemplate: "pitcher-velocity-trend", paramMapping: { player: "player" }, required: false },
+    { queryTemplate: "pitcher-handedness-splits", paramMapping: { player: "player" }, required: true }
+  ],
+  requiredSections: ["Header", "Pitch Arsenal", "Performance Profile", "Splits Analysis", "Trend Analysis", "Risk Assessment", "Comparable Player", "Role Projection"],
+  examples: ['bbdata report pro-pitcher-eval --player "Corbin Burnes"']
+});
+registerReportTemplate({
+  id: "pro-hitter-eval",
+  name: "Pro Hitter Evaluation",
+  category: "pro-scouting",
+  description: "Full MLB/MiLB hitter assessment for acquisition decisions",
+  audiences: ["gm", "scout", "analyst"],
+  templateFile: "pro-hitter-eval.hbs",
+  dataRequirements: [
+    { queryTemplate: "hitter-batted-ball", paramMapping: { player: "player" }, required: true },
+    { queryTemplate: "hitter-vs-pitch-type", paramMapping: { player: "player" }, required: true },
+    { queryTemplate: "hitter-hot-cold-zones", paramMapping: { player: "player" }, required: false }
+  ],
+  requiredSections: ["Header", "Batted Ball Profile", "Approach & Discipline", "Splits Analysis", "Trend Analysis", "Risk Assessment", "Comparable Player", "Role Projection"],
+  examples: ['bbdata report pro-hitter-eval --player "Juan Soto"']
+});
+registerReportTemplate({
+  id: "relief-pitcher-quick",
+  name: "Relief Pitcher Quick Eval",
+  category: "pro-scouting",
+  description: "Fast 1-page evaluation for bullpen additions",
+  audiences: ["gm", "scout"],
+  templateFile: "relief-pitcher-quick.hbs",
+  dataRequirements: [
+    { queryTemplate: "pitcher-arsenal", paramMapping: { player: "player" }, required: true }
+  ],
+  requiredSections: ["Header", "Arsenal", "Key Metrics", "Recommendation"],
+  examples: ['bbdata report relief-pitcher-quick --player "Edwin Diaz"']
+});
+registerReportTemplate({
+  id: "college-pitcher-draft",
+  name: "College Pitcher Draft Report",
+  category: "amateur-scouting",
+  description: "Draft evaluation with tools and projection focus",
+  audiences: ["gm", "scout"],
+  templateFile: "college-pitcher-draft.hbs",
+  dataRequirements: [],
+  requiredSections: ["Header", "Physical", "Arsenal Grades", "Performance", "Projection", "Risk", "Recommendation"],
+  examples: ['bbdata report college-pitcher-draft --player "Chase Burns"']
+});
+registerReportTemplate({
+  id: "college-hitter-draft",
+  name: "College Hitter Draft Report",
+  category: "amateur-scouting",
+  description: "Draft evaluation with tools and projection focus",
+  audiences: ["gm", "scout"],
+  templateFile: "college-hitter-draft.hbs",
+  dataRequirements: [],
+  requiredSections: ["Header", "Physical", "Tool Grades", "Performance", "Projection", "Risk", "Recommendation"],
+  examples: ['bbdata report college-hitter-draft --player "Charlie Condon"']
+});
+registerReportTemplate({
+  id: "hs-prospect",
+  name: "High School Prospect Report",
+  category: "amateur-scouting",
+  description: "Tools-and-projection focused (stats unreliable at HS level)",
+  audiences: ["gm", "scout"],
+  templateFile: "hs-prospect.hbs",
+  dataRequirements: [],
+  requiredSections: ["Header", "Physical", "Tool Grades", "Makeup", "Projection", "Signability", "Recommendation"],
+  examples: ['bbdata report hs-prospect --player "Prospect Name"']
+});
+registerReportTemplate({
+  id: "advance-sp",
+  name: "Advance Report: Starting Pitcher",
+  category: "advance",
+  description: "Game prep for opposing starter \u2014 actionable, 1-page, bullet-point format",
+  audiences: ["coach", "analyst"],
+  templateFile: "advance-sp.hbs",
+  dataRequirements: [
+    { queryTemplate: "pitcher-arsenal", paramMapping: { player: "player" }, required: true },
+    { queryTemplate: "pitcher-handedness-splits", paramMapping: { player: "player" }, required: true }
+  ],
+  requiredSections: ["Header", "Recent Form", "Pitch Mix & Sequencing", "Times Through Order", "Platoon Vulnerabilities", "How to Attack"],
+  examples: ['bbdata report advance-sp --player "Gerrit Cole" --audience coach']
+});
+registerReportTemplate({
+  id: "advance-lineup",
+  name: "Advance Report: Opposing Lineup",
+  category: "advance",
+  description: "Hitter-by-hitter breakdown for pitchers and catchers",
+  audiences: ["coach", "analyst"],
+  templateFile: "advance-lineup.hbs",
+  dataRequirements: [],
+  requiredSections: ["Header", "Lineup Overview", "Hitter Breakdowns", "Key Matchups"],
+  examples: ["bbdata report advance-lineup --team NYY"]
+});
+registerReportTemplate({
+  id: "dev-progress",
+  name: "Development Progress Report",
+  category: "player-dev",
+  description: "Track minor league player growth over time (monthly/quarterly)",
+  audiences: ["scout", "analyst"],
+  templateFile: "dev-progress.hbs",
+  dataRequirements: [],
+  requiredSections: ["Header", "Current Stats", "Trend Analysis", "Mechanical Notes", "Development Goals", "Next Steps"],
+  examples: ['bbdata report dev-progress --player "Jackson Holliday"']
+});
+registerReportTemplate({
+  id: "post-promotion",
+  name: "Post-Promotion Evaluation",
+  category: "player-dev",
+  description: "Assess player adjustment after level change",
+  audiences: ["scout", "analyst"],
+  templateFile: "post-promotion.hbs",
+  dataRequirements: [],
+  requiredSections: ["Header", "Pre-Promotion Stats", "Post-Promotion Stats", "Adjustment Analysis", "Recommendation"],
+  examples: ['bbdata report post-promotion --player "Jackson Holliday"']
+});
+registerReportTemplate({
+  id: "trade-target-onepager",
+  name: "Trade Target One-Pager",
+  category: "executive",
+  description: "Condensed 2-minute evaluation for GM-level trade decisions",
+  audiences: ["gm"],
+  templateFile: "trade-target-onepager.hbs",
+  dataRequirements: [
+    { queryTemplate: "hitter-batted-ball", paramMapping: { player: "player" }, required: false },
+    { queryTemplate: "pitcher-arsenal", paramMapping: { player: "player" }, required: false }
+  ],
+  requiredSections: ["Header", "Key Stats", "Strengths", "Concerns", "Fit Assessment", "Recommendation"],
+  examples: ['bbdata report trade-target-onepager --player "Vladimir Guerrero Jr." --audience gm']
+});
+registerReportTemplate({
+  id: "draft-board-card",
+  name: "Draft Board Summary Card",
+  category: "executive",
+  description: "Glanceable index card for draft room use",
+  audiences: ["gm", "scout"],
+  templateFile: "draft-board-card.hbs",
+  dataRequirements: [],
+  requiredSections: ["Name", "Position", "School", "Tool Grades", "Projection", "Comp", "Round Range"],
+  examples: ['bbdata report draft-board-card --player "Prospect Name"']
+});
+
+// src/commands/report.ts
+Handlebars.registerHelper("grade", (value) => formatGrade(value));
+Handlebars.registerHelper("gradeLabel", (value) => gradeLabel(value));
+Handlebars.registerHelper("pitchType", (code) => pitchTypeName(code));
+Handlebars.registerHelper("formatStat", (value, decimals) => {
+  if (value === null || value === void 0) return "\u2014";
+  return typeof decimals === "number" ? Number(value).toFixed(decimals) : String(value);
+});
+Handlebars.registerHelper("compare", (value, leagueAvg) => {
+  if (value === null || value === void 0) return "\u2014";
+  const diff = value - leagueAvg;
+  const pct = leagueAvg !== 0 ? (diff / leagueAvg * 100).toFixed(1) : "0";
+  return diff > 0 ? `+${pct}%` : `${pct}%`;
+});
+Handlebars.registerHelper("ifGt", function(a, b, options) {
+  return a > b ? options.fn(this) : options.inverse(this);
+});
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var BUNDLED_TEMPLATES_DIR = join2(__dirname2, "..", "templates", "reports");
+function loadTemplate(templateFile) {
+  const userDir = join2(getTemplatesDir(), "reports");
+  const userPath = join2(userDir, templateFile);
+  if (existsSync2(userPath)) {
+    return readFileSync2(userPath, "utf-8");
+  }
+  const bundledPath = join2(BUNDLED_TEMPLATES_DIR, templateFile);
+  if (existsSync2(bundledPath)) {
+    return readFileSync2(bundledPath, "utf-8");
+  }
+  return generateFallbackTemplate(templateFile);
+}
+function generateFallbackTemplate(templateFile) {
+  const templateId = templateFile.replace(".hbs", "");
+  const template13 = getReportTemplate(templateId);
+  if (!template13) return "# Report\n\n{{data}}";
+  const sections = template13.requiredSections.map((s) => `## ${s}
+
+{{!-- ${s} data goes here --}}
+*Data pending*
+`).join("\n");
+  return `# ${template13.name}
+
+**Player:** {{player}}
+**Season:** {{season}}
+**Audience:** {{audience}}
+**Generated:** {{date}}
+
+---
+
+${sections}
+
+---
+*Generated by bbdata CLI \xB7 Data sources: {{sources}}*
+`;
+}
+async function report(options) {
+  const config = getConfig();
+  const audience = options.audience ?? config.defaultAudience;
+  const template13 = getReportTemplate(options.template);
+  if (!template13) {
+    const available = listReportTemplates().map((t) => `  ${t.id} \u2014 ${t.description}`).join("\n");
+    throw new Error(`Unknown report template "${options.template}". Available:
+${available}`);
+  }
+  const season = options.season ?? (/* @__PURE__ */ new Date()).getFullYear();
+  const player = options.player ?? "Unknown";
+  const dataResults = {};
+  const dataSources = [];
+  for (const req of template13.dataRequirements) {
+    try {
+      const result = await query({
+        template: req.queryTemplate,
+        player: options.player,
+        team: options.team,
+        season,
+        format: "json"
+      });
+      dataResults[req.queryTemplate] = result.data;
+      if (!dataSources.includes(result.meta.source)) {
+        dataSources.push(result.meta.source);
+      }
+    } catch (error) {
+      if (req.required) {
+        log.warn(`Required data "${req.queryTemplate}" failed: ${error}`);
+      }
+      dataResults[req.queryTemplate] = null;
+    }
+  }
+  const hbsSource = loadTemplate(template13.templateFile);
+  const compiled = Handlebars.compile(hbsSource);
+  const content = compiled({
+    player,
+    season,
+    audience,
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    sources: dataSources.join(", ") || "none",
+    data: dataResults,
+    ...dataResults
+  });
+  let validation;
+  if (options.validate) {
+    validation = validateReport(content, template13.requiredSections);
+  }
+  const formatted = options.format === "json" ? JSON.stringify({ content, validation, meta: { template: template13.id, player, audience, season, dataSources } }, null, 2) + "\n" : content + "\n";
+  return {
+    content,
+    formatted,
+    validation,
+    meta: {
+      template: template13.id,
+      player,
+      audience,
+      season,
+      dataSources
+    }
+  };
+}
+function validateReport(content, requiredSections) {
+  const issues = [];
+  for (const section of requiredSections) {
+    if (!content.includes(section)) {
+      issues.push({ severity: "warning", message: `Missing section: "${section}"` });
+    }
+  }
+  if (content.includes("Data pending") || content.includes("data goes here")) {
+    issues.push({ severity: "error", message: "Report contains placeholder text \u2014 data was not populated" });
+  }
+  const genericPhrases = ["shows promise", "solid player", "good potential", "talented athlete"];
+  for (const phrase of genericPhrases) {
+    if (content.toLowerCase().includes(phrase)) {
+      issues.push({ severity: "warning", message: `Generic language detected: "${phrase}" \u2014 be more specific` });
+    }
+  }
+  if (content.length < 200) {
+    issues.push({ severity: "warning", message: "Report seems too short \u2014 may be missing content" });
+  }
+  return {
+    passed: issues.filter((i) => i.severity === "error").length === 0,
+    issues
+  };
+}
+export {
+  getConfig,
+  query,
+  report,
+  setConfig
+};
+//# sourceMappingURL=index.js.map