fitzroy 1.0.0 → 1.0.1

package/dist/cli.js

@@ -1,11 +1,653 @@
 #!/usr/bin/env node
-import {
-  __require
-} from "./shared/chunk-xv8z2kms.js";
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// src/cli.ts
-import { defineCommand, runMain } from "citty";
+// src/index.ts
+var init_src = () => {};
+
+// src/cli/formatters/csv.ts
+function escapeField(value) {
+  if (value.includes(",") || value.includes('"') || value.includes(`
+`) || value.includes("\r")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function toStringValue(value) {
+  if (value === null || value === undefined)
+    return "";
+  if (value instanceof Date)
+    return value.toISOString();
+  if (typeof value === "object")
+    return JSON.stringify(value);
+  return String(value);
+}
+function formatCsv(data) {
+  if (data.length === 0)
+    return "";
+  const firstRow = data[0];
+  if (!firstRow)
+    return "";
+  const headers = Object.keys(firstRow);
+  const lines = [headers.map(escapeField).join(",")];
+  for (const row of data) {
+    const values = headers.map((h) => escapeField(toStringValue(row[h])));
+    lines.push(values.join(","));
+  }
+  return lines.join(`
+`);
+}
+
+// src/cli/formatters/json.ts
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+
+// src/cli/formatters/table.ts
+function toDisplayValue(value) {
+  if (value === null || value === undefined)
+    return "-";
+  if (value instanceof Date)
+    return value.toISOString().slice(0, 16).replace("T", " ");
+  if (typeof value === "object")
+    return JSON.stringify(value);
+  return String(value);
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen)
+    return str;
+  return `${str.slice(0, maxLen - 1)}…`;
+}
+function formatTable(data, options = {}) {
+  if (data.length === 0)
+    return "No data.";
+  const firstRow = data[0];
+  if (!firstRow)
+    return "No data.";
+  const termWidth = options.terminalWidth ?? process.stdout.columns ?? 120;
+  const allKeys = Object.keys(firstRow);
+  let columns;
+  if (options.full || !options.columns || options.columns.length === 0) {
+    columns = allKeys.map((key) => ({ key }));
+  } else {
+    columns = [...options.columns];
+  }
+  const colWidths = columns.map((col) => (col.label ?? col.key).length);
+  for (const row of data) {
+    for (let i = 0;i < columns.length; i++) {
+      const col = columns[i];
+      if (!col)
+        continue;
+      const len = toDisplayValue(row[col.key]).length;
+      const current = colWidths[i];
+      if (current !== undefined && len > current) {
+        colWidths[i] = len;
+      }
+    }
+  }
+  for (let i = 0;i < columns.length; i++) {
+    const col = columns[i];
+    const width = colWidths[i];
+    if (!col || width === undefined)
+      continue;
+    colWidths[i] = Math.min(col.maxWidth ?? 30, width);
+  }
+  const gap = 2;
+  const visibleCols = [];
+  let usedWidth = 0;
+  for (let i = 0;i < columns.length; i++) {
+    const colWidth = colWidths[i];
+    if (colWidth === undefined)
+      continue;
+    const needed = usedWidth > 0 ? colWidth + gap : colWidth;
+    if (usedWidth + needed > termWidth && visibleCols.length > 0)
+      break;
+    visibleCols.push(i);
+    usedWidth += needed;
+  }
+  const headerParts = visibleCols.map((i) => {
+    const col = columns[i];
+    const width = colWidths[i];
+    if (!col || width === undefined)
+      return "";
+    const label = (col.label ?? col.key).toUpperCase();
+    return truncate(label, width).padEnd(width);
+  });
+  const header = headerParts.join("  ");
+  const separator = visibleCols.map((i) => {
+    const width = colWidths[i];
+    if (width === undefined)
+      return "";
+    return "─".repeat(width);
+  }).join("  ");
+  const rows = data.map((row) => {
+    const parts = visibleCols.map((i) => {
+      const col = columns[i];
+      const width = colWidths[i];
+      if (!col || width === undefined)
+        return "";
+      const val = toDisplayValue(row[col.key]);
+      return truncate(val, width).padEnd(width);
+    });
+    return parts.join("  ");
+  });
+  return [header, separator, ...rows].join(`
+`);
+}
+
+// src/cli/formatters/index.ts
+function resolveFormat(options) {
+  if (options.json)
+    return "json";
+  if (options.csv)
+    return "csv";
+  if (options.format === "json" || options.format === "csv" || options.format === "table") {
+    return options.format;
+  }
+  if (!process.stdout.isTTY)
+    return "json";
+  return "table";
+}
+function formatOutput(data, options) {
+  const rows = data;
+  const format = resolveFormat(options);
+  switch (format) {
+    case "json":
+      return formatJson(rows);
+    case "csv":
+      return formatCsv(rows);
+    case "table":
+      return formatTable(rows, {
+        columns: options.columns,
+        full: options.full ?? false
+      });
+  }
+}
+var init_formatters = () => {};
+
+// src/cli/ui.ts
+import { spinner } from "@clack/prompts";
 import pc from "picocolors";
+async function withSpinner(message, fn) {
+  if (!isTTY) {
+    return fn();
+  }
+  const s = spinner();
+  s.start(message);
+  try {
+    const result = await fn();
+    s.stop(message);
+    return result;
+  } catch (error) {
+    s.error("Failed");
+    throw error;
+  }
+}
+function showSummary(message) {
+  if (!isTTY)
+    return;
+  console.error(pc.dim(message));
+}
+var isTTY;
+var init_ui = __esm(() => {
+  isTTY = process.stdout.isTTY === true;
+});
+
+// src/cli/commands/matches.ts
+var exports_matches = {};
+__export(exports_matches, {
+  matchesCommand: () => matchesCommand
+});
+import { defineCommand } from "citty";
+var DEFAULT_COLUMNS, matchesCommand;
+var init_matches = __esm(() => {
+  init_src();
+  init_formatters();
+  init_ui();
+  DEFAULT_COLUMNS = [
+    { key: "date", label: "Date", maxWidth: 16 },
+    { key: "roundNumber", label: "Round", maxWidth: 6 },
+    { key: "homeTeam", label: "Home", maxWidth: 20 },
+    { key: "awayTeam", label: "Away", maxWidth: 20 },
+    { key: "homePoints", label: "H.Pts", maxWidth: 6 },
+    { key: "awayPoints", label: "A.Pts", maxWidth: 6 },
+    { key: "venue", label: "Venue", maxWidth: 24 }
+  ];
+  matchesCommand = defineCommand({
+    meta: {
+      name: "matches",
+      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" }
+    },
+    async run({ args }) {
+      const season = Number(args.season);
+      const round = args.round ? Number(args.round) : undefined;
+      const result = await withSpinner("Fetching match results…", () => fetchMatchResults({
+        source: args.source,
+        season,
+        round,
+        competition: args.competition
+      }));
+      if (!result.success) {
+        throw result.error;
+      }
+      const data = result.data;
+      showSummary(`Loaded ${data.length} matches for ${season}${round ? ` round ${round}` : ""}`);
+      const formatOptions = {
+        json: args.json,
+        csv: args.csv,
+        format: args.format,
+        full: args.full,
+        columns: DEFAULT_COLUMNS
+      };
+      console.log(formatOutput(data, formatOptions));
+    }
+  });
+});
+
+// src/cli/commands/stats.ts
+var exports_stats = {};
+__export(exports_stats, {
+  statsCommand: () => statsCommand
+});
+import { defineCommand as defineCommand2 } from "citty";
+var DEFAULT_COLUMNS2, statsCommand;
+var init_stats = __esm(() => {
+  init_src();
+  init_formatters();
+  init_ui();
+  DEFAULT_COLUMNS2 = [
+    { key: "displayName", label: "Player", maxWidth: 22 },
+    { key: "team", label: "Team", maxWidth: 18 },
+    { key: "disposals", label: "Disp", maxWidth: 6 },
+    { key: "kicks", label: "Kicks", maxWidth: 6 },
+    { key: "handballs", label: "HB", maxWidth: 6 },
+    { key: "marks", label: "Marks", maxWidth: 6 },
+    { key: "goals", label: "Goals", maxWidth: 6 }
+  ];
+  statsCommand = defineCommand2({
+    meta: {
+      name: "stats",
+      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" }
+    },
+    async run({ args }) {
+      const season = Number(args.season);
+      const round = args.round ? Number(args.round) : undefined;
+      const matchId = args["match-id"];
+      const result = await withSpinner("Fetching player stats…", () => fetchPlayerStats({
+        source: args.source,
+        season,
+        round,
+        matchId,
+        competition: args.competition
+      }));
+      if (!result.success) {
+        throw result.error;
+      }
+      const data = result.data;
+      showSummary(`Loaded ${data.length} player stat lines for ${season}${round ? ` round ${round}` : ""}`);
+      const formatOptions = {
+        json: args.json,
+        csv: args.csv,
+        format: args.format,
+        full: args.full,
+        columns: DEFAULT_COLUMNS2
+      };
+      console.log(formatOutput(data, formatOptions));
+    }
+  });
+});
+
+// src/cli/commands/fixture.ts
+var exports_fixture = {};
+__export(exports_fixture, {
+  fixtureCommand: () => fixtureCommand
+});
+import { defineCommand as defineCommand3 } from "citty";
+var DEFAULT_COLUMNS3, fixtureCommand;
+var init_fixture = __esm(() => {
+  init_src();
+  init_formatters();
+  init_ui();
+  DEFAULT_COLUMNS3 = [
+    { key: "roundNumber", label: "Round", maxWidth: 6 },
+    { key: "date", label: "Date", maxWidth: 16 },
+    { key: "homeTeam", label: "Home", maxWidth: 20 },
+    { key: "awayTeam", label: "Away", maxWidth: 20 },
+    { key: "venue", label: "Venue", maxWidth: 24 }
+  ];
+  fixtureCommand = defineCommand3({
+    meta: {
+      name: "fixture",
+      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" }
+    },
+    async run({ args }) {
+      const season = Number(args.season);
+      const round = args.round ? Number(args.round) : undefined;
+      const result = await withSpinner("Fetching fixture…", () => fetchFixture({
+        source: args.source,
+        season,
+        round,
+        competition: args.competition
+      }));
+      if (!result.success) {
+        throw result.error;
+      }
+      const data = result.data;
+      showSummary(`Loaded ${data.length} fixtures for ${season}${round ? ` round ${round}` : ""}`);
+      const formatOptions = {
+        json: args.json,
+        csv: args.csv,
+        format: args.format,
+        full: args.full,
+        columns: DEFAULT_COLUMNS3
+      };
+      console.log(formatOutput(data, formatOptions));
+    }
+  });
+});
+
+// src/cli/commands/ladder.ts
+var exports_ladder = {};
+__export(exports_ladder, {
+  ladderCommand: () => ladderCommand
+});
+import { defineCommand as defineCommand4 } from "citty";
+var DEFAULT_COLUMNS4, ladderCommand;
+var init_ladder = __esm(() => {
+  init_src();
+  init_formatters();
+  init_ui();
+  DEFAULT_COLUMNS4 = [
+    { key: "position", label: "Pos", maxWidth: 4 },
+    { key: "team", label: "Team", maxWidth: 24 },
+    { key: "wins", label: "W", maxWidth: 4 },
+    { key: "losses", label: "L", maxWidth: 4 },
+    { key: "draws", label: "D", maxWidth: 4 },
+    { key: "percentage", label: "Pct", maxWidth: 8 },
+    { key: "premiershipsPoints", label: "Pts", maxWidth: 5 }
+  ];
+  ladderCommand = defineCommand4({
+    meta: {
+      name: "ladder",
+      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" }
+    },
+    async run({ args }) {
+      const season = Number(args.season);
+      const round = args.round ? Number(args.round) : undefined;
+      const result = await withSpinner("Fetching ladder…", () => fetchLadder({
+        source: args.source,
+        season,
+        round,
+        competition: args.competition
+      }));
+      if (!result.success) {
+        throw result.error;
+      }
+      const data = result.data;
+      showSummary(`Loaded ladder for ${season}${round ? ` round ${round}` : ""} (${data.entries.length} teams)`);
+      const formatOptions = {
+        json: args.json,
+        csv: args.csv,
+        format: args.format,
+        full: args.full,
+        columns: DEFAULT_COLUMNS4
+      };
+      console.log(formatOutput(data.entries, formatOptions));
+    }
+  });
+});
+
+// src/cli/commands/lineup.ts
+var exports_lineup = {};
+__export(exports_lineup, {
+  lineupCommand: () => lineupCommand
+});
+import { defineCommand as defineCommand5 } from "citty";
+var DEFAULT_COLUMNS5, lineupCommand;
+var init_lineup = __esm(() => {
+  init_src();
+  init_formatters();
+  init_ui();
+  DEFAULT_COLUMNS5 = [
+    { key: "matchId", label: "Match", maxWidth: 12 },
+    { key: "homeTeam", label: "Home", maxWidth: 20 },
+    { key: "awayTeam", label: "Away", maxWidth: 20 }
+  ];
+  lineupCommand = defineCommand5({
+    meta: {
+      name: "lineup",
+      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" }
+    },
+    async run({ args }) {
+      const season = Number(args.season);
+      const round = Number(args.round);
+      const matchId = args["match-id"];
+      const result = await withSpinner("Fetching lineups…", () => fetchLineup({
+        source: args.source,
+        season,
+        round,
+        matchId,
+        competition: args.competition
+      }));
+      if (!result.success) {
+        throw result.error;
+      }
+      const data = result.data;
+      showSummary(`Loaded ${data.length} lineups for ${season} round ${round}`);
+      const formatOptions = {
+        json: args.json,
+        csv: args.csv,
+        format: args.format,
+        full: args.full,
+        columns: DEFAULT_COLUMNS5
+      };
+      console.log(formatOutput(data, formatOptions));
+    }
+  });
+});
+
+// src/cli/commands/squad.ts
+var exports_squad = {};
+__export(exports_squad, {
+  squadCommand: () => squadCommand
+});
+import { defineCommand as defineCommand6 } from "citty";
+var DEFAULT_COLUMNS6, squadCommand;
+var init_squad = __esm(() => {
+  init_src();
+  init_formatters();
+  init_ui();
+  DEFAULT_COLUMNS6 = [
+    { key: "displayName", label: "Player", maxWidth: 24 },
+    { key: "jumperNumber", label: "#", maxWidth: 4 },
+    { key: "position", label: "Pos", maxWidth: 12 },
+    { key: "heightCm", label: "Ht", maxWidth: 5 },
+    { key: "weightKg", label: "Wt", maxWidth: 5 }
+  ];
+  squadCommand = defineCommand6({
+    meta: {
+      name: "squad",
+      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" }
+    },
+    async run({ args }) {
+      const teamId = args["team-id"];
+      const season = Number(args.season);
+      const result = await withSpinner("Fetching squad…", () => fetchSquad({
+        teamId,
+        season,
+        competition: args.competition
+      }));
+      if (!result.success) {
+        throw result.error;
+      }
+      const data = result.data;
+      showSummary(`Loaded ${data.players.length} players for ${data.teamName} ${season}`);
+      const formatOptions = {
+        json: args.json,
+        csv: args.csv,
+        format: args.format,
+        full: args.full,
+        columns: DEFAULT_COLUMNS6
+      };
+      console.log(formatOutput(data.players, formatOptions));
+    }
+  });
+});
+
+// src/cli/commands/teams.ts
+var exports_teams = {};
+__export(exports_teams, {
+  teamsCommand: () => teamsCommand
+});
+import { defineCommand as defineCommand7 } from "citty";
+var DEFAULT_COLUMNS7, teamsCommand;
+var init_teams = __esm(() => {
+  init_src();
+  init_formatters();
+  init_ui();
+  DEFAULT_COLUMNS7 = [
+    { key: "teamId", label: "ID", maxWidth: 8 },
+    { key: "name", label: "Team", maxWidth: 24 },
+    { key: "abbreviation", label: "Abbr", maxWidth: 6 },
+    { key: "competition", label: "Comp", maxWidth: 6 }
+  ];
+  teamsCommand = defineCommand7({
+    meta: {
+      name: "teams",
+      description: "Fetch team list"
+    },
+    args: {
+      competition: { type: "string", description: "Competition code (AFLM or AFLW)" },
+      "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" }
+    },
+    async run({ args }) {
+      const result = await withSpinner("Fetching teams…", () => fetchTeams({
+        competition: args.competition,
+        teamType: args["team-type"]
+      }));
+      if (!result.success) {
+        throw result.error;
+      }
+      const data = result.data;
+      showSummary(`Loaded ${data.length} teams`);
+      const formatOptions = {
+        json: args.json,
+        csv: args.csv,
+        format: args.format,
+        full: args.full,
+        columns: DEFAULT_COLUMNS7
+      };
+      console.log(formatOutput(data, formatOptions));
+    }
+  });
+});
+
+// src/cli.ts
+import { defineCommand as defineCommand8, runMain } from "citty";
+import pc2 from "picocolors";
 
 // src/lib/errors.ts
 class AflApiError extends Error {
@@ -45,44 +687,44 @@ class ValidationError extends Error {
 }
 
 // src/cli.ts
-var main = defineCommand({
+var main = defineCommand8({
   meta: {
     name: "fitzroy",
-    version: "1.0.0",
+    version: "1.0.1",
     description: "CLI for fetching AFL data — match results, player stats, fixtures, ladders, and more"
   },
   subCommands: {
-    matches: () => import("./shared/chunk-kr78ch1j.js").then((m) => m.matchesCommand),
-    stats: () => import("./shared/chunk-ngvkaczn.js").then((m) => m.statsCommand),
-    fixture: () => import("./shared/chunk-99nkfy8s.js").then((m) => m.fixtureCommand),
-    ladder: () => import("./shared/chunk-d6fkap72.js").then((m) => m.ladderCommand),
-    lineup: () => import("./shared/chunk-9zcjfgwe.js").then((m) => m.lineupCommand),
-    squad: () => import("./shared/chunk-c7vawngt.js").then((m) => m.squadCommand),
-    teams: () => import("./shared/chunk-b380x0p6.js").then((m) => m.teamsCommand)
+    matches: () => Promise.resolve().then(() => (init_matches(), exports_matches)).then((m) => m.matchesCommand),
+    stats: () => Promise.resolve().then(() => (init_stats(), exports_stats)).then((m) => m.statsCommand),
+    fixture: () => Promise.resolve().then(() => (init_fixture(), exports_fixture)).then((m) => m.fixtureCommand),
+    ladder: () => Promise.resolve().then(() => (init_ladder(), exports_ladder)).then((m) => m.ladderCommand),
+    lineup: () => Promise.resolve().then(() => (init_lineup(), exports_lineup)).then((m) => m.lineupCommand),
+    squad: () => Promise.resolve().then(() => (init_squad(), exports_squad)).then((m) => m.squadCommand),
+    teams: () => Promise.resolve().then(() => (init_teams(), exports_teams)).then((m) => m.teamsCommand)
   }
 });
 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:")}
+    const issueLines = error.issues.map((i) => `  ${pc2.yellow(i.path)}: ${i.message}`);
+    return `${pc2.red("Validation error:")}
 ${issueLines.join(`
 `)}`;
   }
   if (error instanceof AflApiError) {
     const status = error.statusCode ? ` (HTTP ${error.statusCode})` : "";
-    return `${pc.red("AFL API error:")} ${error.message}${status}`;
+    return `${pc2.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}`;
+    return `${pc2.red("Scrape error:")} ${error.message}${source}`;
   }
   if (error instanceof UnsupportedSourceError) {
-    return `${pc.red("Unsupported source:")} ${error.message}`;
+    return `${pc2.red("Unsupported source:")} ${error.message}`;
   }
   if (error instanceof Error) {
-    return `${pc.red("Error:")} ${error.message}`;
+    return `${pc2.red("Error:")} ${error.message}`;
   }
-  return `${pc.red("Error:")} ${String(error)}`;
+  return `${pc2.red("Error:")} ${String(error)}`;
 }
 runMain(main).catch((error) => {
   console.error(formatError(error));