@d3lm/pr-stats 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1760 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/asciichart@1.5.25/node_modules/asciichart/asciichart.js
+var require_asciichart = __commonJS({
+  "../../node_modules/.pnpm/asciichart@1.5.25/node_modules/asciichart/asciichart.js"(exports) {
+    "use strict";
+    (function(exports2) {
+      exports2.black = "\x1B[30m";
+      exports2.red = "\x1B[31m";
+      exports2.green = "\x1B[32m";
+      exports2.yellow = "\x1B[33m";
+      exports2.blue = "\x1B[34m";
+      exports2.magenta = "\x1B[35m";
+      exports2.cyan = "\x1B[36m";
+      exports2.lightgray = "\x1B[37m";
+      exports2.default = "\x1B[39m";
+      exports2.darkgray = "\x1B[90m";
+      exports2.lightred = "\x1B[91m";
+      exports2.lightgreen = "\x1B[92m";
+      exports2.lightyellow = "\x1B[93m";
+      exports2.lightblue = "\x1B[94m";
+      exports2.lightmagenta = "\x1B[95m";
+      exports2.lightcyan = "\x1B[96m";
+      exports2.white = "\x1B[97m";
+      exports2.reset = "\x1B[0m";
+      function colored(char, color) {
+        return color === void 0 ? char : color + char + exports2.reset;
+      }
+      exports2.colored = colored;
+      exports2.plot = function(series, cfg = void 0) {
+        if (typeof series[0] == "number") {
+          series = [series];
+        }
+        cfg = typeof cfg !== "undefined" ? cfg : {};
+        let min = typeof cfg.min !== "undefined" ? cfg.min : series[0][0];
+        let max = typeof cfg.max !== "undefined" ? cfg.max : series[0][0];
+        for (let j = 0; j < series.length; j++) {
+          for (let i = 0; i < series[j].length; i++) {
+            min = Math.min(min, series[j][i]);
+            max = Math.max(max, series[j][i]);
+          }
+        }
+        let defaultSymbols = ["\u253C", "\u2524", "\u2576", "\u2574", "\u2500", "\u2570", "\u256D", "\u256E", "\u256F", "\u2502"];
+        let range = Math.abs(max - min);
+        let offset = typeof cfg.offset !== "undefined" ? cfg.offset : 3;
+        let padding = typeof cfg.padding !== "undefined" ? cfg.padding : "           ";
+        let height = typeof cfg.height !== "undefined" ? cfg.height : range;
+        let colors = typeof cfg.colors !== "undefined" ? cfg.colors : [];
+        let ratio = range !== 0 ? height / range : 1;
+        let min2 = Math.round(min * ratio);
+        let max2 = Math.round(max * ratio);
+        let rows = Math.abs(max2 - min2);
+        let width = 0;
+        for (let i = 0; i < series.length; i++) {
+          width = Math.max(width, series[i].length);
+        }
+        width = width + offset;
+        let symbols = typeof cfg.symbols !== "undefined" ? cfg.symbols : defaultSymbols;
+        let format = typeof cfg.format !== "undefined" ? cfg.format : function(x) {
+          return (padding + x.toFixed(2)).slice(-padding.length);
+        };
+        let result = new Array(rows + 1);
+        for (let i = 0; i <= rows; i++) {
+          result[i] = new Array(width);
+          for (let j = 0; j < width; j++) {
+            result[i][j] = " ";
+          }
+        }
+        for (let y = min2; y <= max2; ++y) {
+          let label = format(rows > 0 ? max - (y - min2) * range / rows : y, y - min2);
+          result[y - min2][Math.max(offset - label.length, 0)] = label;
+          result[y - min2][offset - 1] = y == 0 ? symbols[0] : symbols[1];
+        }
+        for (let j = 0; j < series.length; j++) {
+          let currentColor = colors[j % colors.length];
+          let y0 = Math.round(series[j][0] * ratio) - min2;
+          result[rows - y0][offset - 1] = colored(symbols[0], currentColor);
+          for (let x = 0; x < series[j].length - 1; x++) {
+            let y02 = Math.round(series[j][x + 0] * ratio) - min2;
+            let y1 = Math.round(series[j][x + 1] * ratio) - min2;
+            if (y02 == y1) {
+              result[rows - y02][x + offset] = colored(symbols[4], currentColor);
+            } else {
+              result[rows - y1][x + offset] = colored(y02 > y1 ? symbols[5] : symbols[6], currentColor);
+              result[rows - y02][x + offset] = colored(y02 > y1 ? symbols[7] : symbols[8], currentColor);
+              let from = Math.min(y02, y1);
+              let to = Math.max(y02, y1);
+              for (let y = from + 1; y < to; y++) {
+                result[rows - y][x + offset] = colored(symbols[9], currentColor);
+              }
+            }
+          }
+        }
+        return result.map(function(x) {
+          return x.join("");
+        }).join("\n");
+      };
+    })(typeof exports === "undefined" ? (
+      /* istanbul ignore next */
+      exports["asciichart"] = {}
+    ) : exports);
+  }
+});
+
+// github.mjs
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+// utils.mjs
+function fail(message) {
+  console.error(`Error: ${message}`);
+  process.exit(1);
+}
+function formatMinutesOfDay(minutes) {
+  return `${Math.floor(minutes / 60)}:${String(minutes % 60).padStart(2, "0")}`;
+}
+function percentile(sorted, percent) {
+  const index = Math.min(sorted.length - 1, Math.ceil(percent / 100 * sorted.length) - 1);
+  return sorted[Math.max(0, index)];
+}
+function link(text, url) {
+  if (!process.stdout.isTTY) {
+    return text;
+  }
+  return `\x1B]8;;${url}\x1B\\${text}\x1B]8;;\x1B\\`;
+}
+
+// github.mjs
+var execFileAsync = promisify(execFile);
+var API_BASE = "https://api.github.com";
+var token;
+function configureAuth(cliToken) {
+  token = cliToken ?? process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+}
+async function gh(args) {
+  try {
+    const { stdout } = await execFileAsync("gh", args, {
+      maxBuffer: 64 * 1024 * 1024
+    });
+    return stdout;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      fail("the gh CLI is not installed, install it or provide a token via --token or GITHUB_TOKEN");
+    }
+    const stderr = error.stderr?.toString().trim();
+    fail(`gh ${args.slice(0, 2).join(" ")} failed${stderr ? `
+${stderr}` : ""}`);
+    throw error;
+  }
+}
+async function api(path, { method = "GET", body } = {}) {
+  let response;
+  try {
+    response = await fetch(`${API_BASE}${path}`, {
+      method,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github+json",
+        "User-Agent": "pr-stats",
+        ...body === void 0 ? {} : { "Content-Type": "application/json" }
+      },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) }
+    });
+  } catch (error) {
+    fail(`cannot reach ${API_BASE} (${error.cause?.message ?? error.message})`);
+  }
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    const message = payload?.message ?? "";
+    const endpoint = path.split("?")[0];
+    fail(`GitHub API ${method} ${endpoint} failed with ${response.status}${message ? ` (${message})` : ""}`);
+  }
+  return payload;
+}
+async function runGraphql(query) {
+  if (token) {
+    const result = await api("/graphql", { method: "POST", body: { query } });
+    if (!result?.data) {
+      const message = result?.errors?.[0]?.message;
+      fail(`GitHub GraphQL query failed${message ? ` (${message})` : ""}`);
+    }
+    return result.data;
+  }
+  const stdout = await gh(["api", "graphql", "-f", `query=${query}`]);
+  return JSON.parse(stdout).data;
+}
+async function fetchCurrentUser() {
+  if (token) {
+    const user = await api("/user");
+    return user.login;
+  }
+  const stdout = await gh(["api", "user", "--jq", ".login"]);
+  return stdout.trim();
+}
+async function fetchDefaultOwner() {
+  if (!token) {
+    const stdout = await gh(["repo", "view", "--json", "owner", "--jq", ".owner.login"]);
+    return stdout.trim();
+  }
+  try {
+    const { stdout } = await execFileAsync("git", ["remote", "get-url", "origin"]);
+    const match = /github\.com[/:]([^/]+)\//.exec(stdout);
+    return match?.[1] ?? "";
+  } catch {
+    return "";
+  }
+}
+async function resolveRepos(repos) {
+  let defaultOwner;
+  const resolved = [];
+  for (const repo of repos) {
+    if (repo.includes("/")) {
+      resolved.push(repo);
+      continue;
+    }
+    if (!defaultOwner) {
+      defaultOwner = await fetchDefaultOwner();
+      if (!defaultOwner) {
+        fail(`cannot resolve owner for "--repo ${repo}", use the owner/name form`);
+      }
+    }
+    resolved.push(`${defaultOwner}/${repo}`);
+  }
+  return resolved;
+}
+async function searchPrsViaApi({ user, sinceIso, repos, includeDrafts, mode }) {
+  const qualifier = {
+    requested: "review-requested",
+    reviewed: "reviewed-by",
+    authored: "author"
+  }[mode];
+  const terms = ["type:pr", `${qualifier}:${user}`, `created:>=${sinceIso}`];
+  if (!includeDrafts) {
+    terms.push("draft:false");
+  }
+  for (const repo of repos) {
+    terms.push(`repo:${repo}`);
+  }
+  const query = encodeURIComponent(terms.join(" "));
+  const items = [];
+  for (let page = 1; page <= 10; page++) {
+    const result = await api(`/search/issues?q=${query}&per_page=100&page=${page}`);
+    items.push(...result.items);
+    if (result.items.length === 0 || items.length >= result.total_count) {
+      break;
+    }
+  }
+  return items.map((item) => {
+    return {
+      number: item.number,
+      repository: { nameWithOwner: item.repository_url.replace(`${API_BASE}/repos/`, "") },
+      title: item.title,
+      url: item.html_url,
+      createdAt: item.created_at,
+      isDraft: item.draft,
+      state: item.state
+    };
+  });
+}
+async function searchPrs({ user, sinceIso, repos, includeDrafts, mode }) {
+  if (token) {
+    return searchPrsViaApi({ user, sinceIso, repos, includeDrafts, mode });
+  }
+  const modeFlag = {
+    requested: "--review-requested",
+    reviewed: "--reviewed-by",
+    authored: "--author"
+  }[mode];
+  const args = [
+    "search",
+    "prs",
+    modeFlag,
+    user,
+    "--created",
+    `>=${sinceIso}`,
+    "--limit",
+    "1000",
+    "--json",
+    "number,repository,title,url,createdAt,isDraft,state"
+  ];
+  if (!includeDrafts) {
+    args.push("--draft=false");
+  }
+  for (const repo of repos) {
+    args.push("--repo", repo);
+  }
+  return JSON.parse(await gh(args));
+}
+async function fetchPrDetails(prs) {
+  const parts = prs.map((pr, i) => {
+    const [owner, name] = pr.repo.split("/");
+    return `
+      pr${i}: repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(name)}) {
+        pullRequest(number: ${pr.number}) {
+          timelineItems(itemTypes: [REVIEW_REQUESTED_EVENT], first: 100) {
+            nodes {
+              ... on ReviewRequestedEvent {
+                createdAt
+                requestedReviewer {
+                  ... on User { login }
+                  ... on Team { slug }
+                }
+              }
+            }
+          }
+          reviews(first: 100) {
+            nodes {
+              author { login }
+              submittedAt
+              state
+            }
+          }
+        }
+      }`;
+  });
+  const query = `query {${parts.join("\n")}}`;
+  const data = await runGraphql(query);
+  return prs.map((pr, i) => data[`pr${i}`]?.pullRequest ?? null);
+}
+async function fetchPrSizes(prs) {
+  const parts = prs.map((pr, i) => {
+    const [owner, name] = pr.repo.split("/");
+    return `
+      pr${i}: repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(name)}) {
+        pullRequest(number: ${pr.number}) {
+          additions
+          deletions
+          changedFiles
+        }
+      }`;
+  });
+  const query = `query {${parts.join("\n")}}`;
+  const data = await runGraphql(query);
+  return prs.map((pr, i) => data[`pr${i}`]?.pullRequest ?? null);
+}
+
+// report.mjs
+var import_asciichart = __toESM(require_asciichart(), 1);
+
+// time.mjs
+var timeMode = {
+  business: true,
+  workWindows: [{ startMin: 0, endMin: 24 * 60 }],
+  dayHours: 24,
+  formatter: void 0
+};
+function configureTimeMode({ business, workWindows, tz }) {
+  const workMinutesPerDay = workWindows.reduce((sum, window) => sum + (window.endMin - window.startMin), 0);
+  timeMode.business = business;
+  timeMode.workWindows = workWindows;
+  timeMode.dayHours = business ? workMinutesPerDay / 60 : 24;
+  timeMode.formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+}
+function isFullDayMode() {
+  return timeMode.business && timeMode.dayHours === 24;
+}
+function wallParts(instantMs) {
+  const parts = Object.fromEntries(timeMode.formatter.formatToParts(instantMs).map((part) => [part.type, part.value]));
+  return {
+    year: Number(parts.year),
+    month: Number(parts.month),
+    day: Number(parts.day),
+    hour: Number(parts.hour),
+    minute: Number(parts.minute),
+    second: Number(parts.second)
+  };
+}
+function utcFromWall(wallTargetMs) {
+  let guess = wallTargetMs;
+  for (let i = 0; i < 2; i++) {
+    const parts = wallParts(guess);
+    const wall = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+    guess = wallTargetMs - (wall - guess);
+  }
+  return guess;
+}
+function businessMsBetween(start, end) {
+  const startMs = start.getTime();
+  const endMs = end.getTime();
+  if (endMs <= startMs) {
+    return 0;
+  }
+  let total = 0;
+  const parts = wallParts(startMs);
+  let localDay = Date.UTC(parts.year, parts.month - 1, parts.day);
+  while (utcFromWall(localDay) <= endMs) {
+    const weekday = new Date(localDay).getUTCDay();
+    if (weekday !== 0 && weekday !== 6) {
+      for (const window of timeMode.workWindows) {
+        const windowStart = utcFromWall(localDay + window.startMin * 6e4);
+        const windowEnd = utcFromWall(localDay + window.endMin * 6e4);
+        const overlapStart = Math.max(windowStart, startMs);
+        const overlapEnd = Math.min(windowEnd, endMs);
+        if (overlapEnd > overlapStart) {
+          total += overlapEnd - overlapStart;
+        }
+      }
+    }
+    localDay += 864e5;
+  }
+  return total;
+}
+function durationHours(start, end) {
+  if (!timeMode.business) {
+    return (end - start) / 36e5;
+  }
+  return businessMsBetween(start, end) / 36e5;
+}
+
+// report.mjs
+var BUCKETS = [];
+function initBuckets() {
+  BUCKETS = makeBuckets();
+}
+function makeBuckets() {
+  if (!timeMode.business || isFullDayMode()) {
+    return [
+      { label: "< 1h", max: 1 },
+      { label: "1-4h", max: 4 },
+      { label: "4-8h", max: 8 },
+      { label: "8-24h", max: 24 },
+      { label: "1-2d", max: 48 },
+      { label: "2-4d", max: 96 },
+      { label: "4-7d", max: 168 },
+      { label: "> 7d", max: Infinity }
+    ];
+  }
+  const wd = timeMode.dayHours;
+  return [
+    { label: "< 1h", max: 1 },
+    { label: "1-4h", max: 4 },
+    { label: "4h-1wd", max: wd },
+    { label: "1-2wd", max: 2 * wd },
+    { label: "2-3wd", max: 3 * wd },
+    { label: "3-5wd", max: 5 * wd },
+    { label: "5-10wd", max: 10 * wd },
+    { label: "> 10wd", max: Infinity }
+  ];
+}
+var LINE_BUCKETS = [
+  { label: "< 50", max: 50 },
+  { label: "50-100", max: 100 },
+  { label: "100-250", max: 250 },
+  { label: "250-500", max: 500 },
+  { label: "500-1k", max: 1e3 },
+  { label: "1k-2.5k", max: 2500 },
+  { label: "2.5k-5k", max: 5e3 },
+  { label: "> 5k", max: Infinity }
+];
+var FILE_BUCKETS = [
+  { label: "1-2", max: 3 },
+  { label: "3-5", max: 6 },
+  { label: "6-10", max: 11 },
+  { label: "11-20", max: 21 },
+  { label: "21-50", max: 51 },
+  { label: "> 50", max: Infinity }
+];
+function formatHours(hours) {
+  if (hours < 1) {
+    return `${Math.round(hours * 60)}m`;
+  }
+  if (hours < 2 * timeMode.dayHours) {
+    return `${hours.toFixed(1)}h`;
+  }
+  return `${(hours / timeMode.dayHours).toFixed(1)}${timeMode.business && !isFullDayMode() ? "wd" : "d"}`;
+}
+function formatHoursOnly(hours) {
+  if (hours < 1) {
+    return `${Math.round(hours * 60)}m`;
+  }
+  return `${hours.toFixed(1)}h`;
+}
+function weeksSuffix(hours) {
+  const weekHours = timeMode.business ? 5 * timeMode.dayHours : 7 * 24;
+  if (hours < weekHours) {
+    return "";
+  }
+  return ` (${(hours / weekHours).toFixed(1)} weeks)`;
+}
+function printHistogram(title, values, buckets = BUCKETS) {
+  const counts = buckets.map(() => 0);
+  for (const value2 of values) {
+    counts[buckets.findIndex((bucket) => value2 < bucket.max)] += 1;
+  }
+  const maxCount = Math.max(...counts, 1);
+  const labelWidth = Math.max(...buckets.map((bucket) => bucket.label.length));
+  console.info(`
+${title}`);
+  for (const [i, bucket] of buckets.entries()) {
+    const bar = "\u2588".repeat(Math.round(counts[i] / maxCount * 40)) || (counts[i] > 0 ? "\u258F" : "");
+    const pct = values.length > 0 ? Math.round(counts[i] / values.length * 100) : 0;
+    console.info(`  ${bucket.label.padEnd(labelWidth)}  ${bar.padEnd(40)} ${String(counts[i]).padStart(4)}  (${pct}%)`);
+  }
+}
+function printStats(hoursList, targetHours, targetLabel, pendingHours = []) {
+  const sorted = [...hoursList].toSorted((a, b) => a - b);
+  const mean = sorted.reduce((sum, hours) => sum + hours, 0) / sorted.length;
+  console.info(
+    `
+  min ${formatHours(sorted[0])} | mean ${formatHours(mean)} | p50 ${formatHours(percentile(sorted, 50))} | p90 ${formatHours(percentile(sorted, 90))} | p99 ${formatHours(percentile(sorted, 99))} | max ${formatHours(sorted.at(-1))}`
+  );
+  if (targetHours !== void 0) {
+    const overdue = pendingHours.filter((hours) => hours > targetHours).length;
+    const met = sorted.filter((hours) => hours <= targetHours).length;
+    const total = sorted.length + overdue;
+    const pct = met / total * 100;
+    const filled = Math.round(pct / 100 * 30);
+    const gauge = "\u2588".repeat(filled) + "\u2591".repeat(30 - filled);
+    console.info(
+      `  target <= ${targetLabel}  ${gauge} ${pct.toFixed(0)}% met (${met}/${total}${overdue > 0 ? `, ${overdue} awaiting review and already over` : ""})`
+    );
+  }
+}
+function printSizeStats(title, metrics) {
+  const rows = metrics.map(({ label, values }) => {
+    const sorted = [...values].toSorted((a, b) => a - b);
+    const mean = sorted.reduce((sum, value2) => sum + value2, 0) / sorted.length;
+    return {
+      label,
+      cells: [
+        ["min", String(sorted[0])],
+        ["mean", String(Math.round(mean))],
+        ["p50", String(percentile(sorted, 50))],
+        ["p90", String(percentile(sorted, 90))],
+        ["p99", String(percentile(sorted, 99))],
+        ["max", String(sorted.at(-1))]
+      ]
+    };
+  });
+  const labelWidth = Math.max(...rows.map((row) => row.label.length));
+  const columnWidths = rows[0].cells.map((_, i) => Math.max(...rows.map((row) => row.cells[i][1].length)));
+  console.info(`
+${title}`);
+  for (const row of rows) {
+    const cells = row.cells.map(([name, value2], i) => `${name} ${value2.padStart(columnWidths[i])}`).join(" | ");
+    console.info(`  ${row.label.padEnd(labelWidth)}  ${cells}`);
+  }
+}
+function printQuantileStrips(title, metrics, width = 40) {
+  const rows = metrics.map(({ label, values }) => {
+    const sorted = [...values].toSorted((a, b) => a - b);
+    const min = sorted[0];
+    const max = sorted.at(-1);
+    const span = Math.log1p(max) - Math.log1p(min);
+    const position = (value2) => {
+      if (span === 0) {
+        return 0;
+      }
+      return Math.round((Math.log1p(value2) - Math.log1p(min)) / span * (width - 1));
+    };
+    const cells = Array.from({ length: width }, () => "\u2500");
+    cells[0] = "\u251C";
+    cells[width - 1] = "\u2524";
+    for (let i = position(percentile(sorted, 25)); i <= position(percentile(sorted, 75)); i++) {
+      cells[i] = "\u2592";
+    }
+    cells[position(percentile(sorted, 50))] = "\u2588";
+    return { label, strip: cells.join(""), min: String(min), max: String(max) };
+  });
+  const labelWidth = Math.max(...rows.map((row) => row.label.length));
+  const minWidth = Math.max(...rows.map((row) => row.min.length));
+  console.info(`
+${title}`);
+  for (const row of rows) {
+    console.info(`  ${row.label.padEnd(labelWidth)}  ${row.min.padStart(minWidth)} ${row.strip} ${row.max}`);
+  }
+}
+function formatCount(value2) {
+  if (value2 < 1e3) {
+    return String(value2);
+  }
+  const scaled = value2 / 1e3;
+  return `${scaled >= 10 ? Math.round(scaled) : scaled.toFixed(1)}k`;
+}
+function printSizeTimeline(values) {
+  const maxPoints = Math.max(40, Math.min((process.stdout.columns ?? 90) - 12, 100));
+  let series = values;
+  let chunk = 1;
+  if (values.length > maxPoints) {
+    chunk = Math.ceil(values.length / maxPoints);
+    series = [];
+    for (let offset = 0; offset < values.length; offset += chunk) {
+      const slice = values.slice(offset, offset + chunk);
+      series.push(slice.reduce((sum, value2) => sum + value2, 0) / slice.length);
+    }
+  }
+  const stretch = Math.floor(maxPoints / series.length);
+  if (stretch > 1) {
+    series = series.flatMap((value2) => Array.from({ length: stretch }, () => value2));
+  }
+  const chart = import_asciichart.default.plot(
+    series.map((value2) => Math.log10(value2 + 1)),
+    {
+      height: 10,
+      format: (x) => formatCount(Math.round(10 ** x - 1)).padStart(7)
+    }
+  );
+  console.info(
+    `
+Lines changed per authored PR over time (n=${values.length}, log scale${chunk > 1 ? `, each point averages ${chunk} PRs` : ""})`
+  );
+  console.info(
+    chart.split("\n").map((line) => `  ${line}`).join("\n")
+  );
+}
+
+// analyze.mjs
+function analyzePr(pr, details, user) {
+  if (!details) {
+    return { kind: "inaccessible", pr };
+  }
+  const requests = details.timelineItems.nodes.filter((node) => node?.requestedReviewer?.login === user).map((node) => new Date(node.createdAt)).toSorted((a, b) => a - b);
+  const reviews = details.reviews.nodes.filter((node) => node?.author?.login === user && node.submittedAt).map((node) => new Date(node.submittedAt)).toSorted((a, b) => a - b);
+  if (requests.length === 0) {
+    return reviews.length > 0 ? { kind: "unrequested", pr } : { kind: "inaccessible", pr };
+  }
+  const firstRequest = requests[0];
+  const firstReviewAfterRequest = reviews.find((review) => review >= firstRequest);
+  if (!firstReviewAfterRequest) {
+    return { kind: "pending", pr, requestedAt: firstRequest };
+  }
+  return {
+    kind: "reviewed",
+    pr,
+    hours: durationHours(firstRequest, firstReviewAfterRequest)
+  };
+}
+async function analyzeReviewTimes({ requested, reviewed, user, targetHours, targetLabel }) {
+  const prByKey = /* @__PURE__ */ new Map();
+  for (const item of [...requested, ...reviewed]) {
+    const repo = item.repository.nameWithOwner;
+    prByKey.set(`${repo}#${item.number}`, {
+      repo,
+      number: item.number,
+      title: item.title,
+      url: item.url,
+      state: item.state
+    });
+  }
+  const prs = [...prByKey.values()];
+  if (prs.length === 0) {
+    console.info("No reviewed or review-requested PRs found.");
+    return;
+  }
+  if (requested.length >= 1e3 || reviewed.length >= 1e3) {
+    console.warn("Warning, a search hit the 1000 result cap, so data may be incomplete. Narrow --since or --repo.");
+  }
+  console.info(`Found ${prs.length} PRs, fetching review timelines...`);
+  const results = [];
+  const batchSize = 25;
+  for (let offset = 0; offset < prs.length; offset += batchSize) {
+    const batch = prs.slice(offset, offset + batchSize);
+    const detailsList = await fetchPrDetails(batch);
+    for (const [i, element] of batch.entries()) {
+      results.push(analyzePr(element, detailsList[i], user));
+    }
+    process.stdout.write(`\r  ${Math.min(offset + batchSize, prs.length)}/${prs.length}`);
+  }
+  process.stdout.write("\n");
+  const reviewedResults = results.filter((result) => result.kind === "reviewed");
+  const pending = results.filter((result) => result.kind === "pending" && result.pr.state === "open");
+  const now = /* @__PURE__ */ new Date();
+  for (const result of pending) {
+    result.hours = durationHours(result.requestedAt, now);
+  }
+  const expired = results.filter((result) => result.kind === "pending" && result.pr.state !== "open");
+  const unrequested = results.filter((result) => result.kind === "unrequested");
+  console.info(
+    `
+${reviewedResults.length} reviewed after a direct request, ${pending.length} open and awaiting your review, ${expired.length} closed or merged without your review, ${unrequested.length} reviewed without a direct request (excluded)`
+  );
+  if (reviewedResults.length === 0) {
+    console.info("Nothing to chart.");
+    return;
+  }
+  const allHours = reviewedResults.map((result) => result.hours);
+  const pendingHours = pending.map((result) => result.hours);
+  printHistogram(`Time to review, all repos (n=${allHours.length})`, allHours);
+  printStats(allHours, targetHours, targetLabel, pendingHours);
+  const byRepo = /* @__PURE__ */ new Map();
+  for (const result of reviewedResults) {
+    if (!byRepo.has(result.pr.repo)) {
+      byRepo.set(result.pr.repo, []);
+    }
+    byRepo.get(result.pr.repo).push(result.hours);
+  }
+  if (byRepo.size > 1) {
+    const sortedByRepo = [...byRepo.entries()].toSorted((a, b) => {
+      return b[1].length - a[1].length;
+    });
+    for (const [repo, hoursList] of sortedByRepo) {
+      printHistogram(`Time to review, ${repo} (n=${hoursList.length})`, hoursList);
+      const repoPendingHours = pending.filter((result) => result.pr.repo === repo).map((result) => result.hours);
+      printStats(hoursList, targetHours, targetLabel, repoPendingHours);
+    }
+  }
+  if (targetHours !== void 0) {
+    const misses = reviewedResults.filter((result) => result.hours > targetHours).toSorted((a, b) => b.hours - a.hours);
+    if (misses.length > 0) {
+      console.info(`
+Reviews that missed the <= ${targetLabel} target`);
+      const rows = misses.map((result) => {
+        return {
+          result,
+          duration: `${formatHoursOnly(result.hours).padStart(8)}${weeksSuffix(result.hours)}`
+        };
+      });
+      const width = Math.max(...rows.map((row) => row.duration.length));
+      for (const { result, duration } of rows) {
+        const ref = link(`${result.pr.repo}#${result.pr.number}`, result.pr.url);
+        console.info(`  ${duration.padEnd(width)}  ${ref}  ${result.pr.title}`);
+      }
+    }
+  }
+  if (pending.length > 0) {
+    console.info("\nOpen and awaiting your review");
+    const rows = pending.toSorted((a, b) => a.requestedAt - b.requestedAt).map((result) => {
+      return {
+        result,
+        duration: `${formatHoursOnly(result.hours).padStart(8)}${weeksSuffix(result.hours)}`
+      };
+    });
+    const width = Math.max(...rows.map((row) => row.duration.length));
+    for (const { result, duration } of rows) {
+      const ref = link(`${result.pr.repo}#${result.pr.number}`, result.pr.url);
+      console.info(`  ${duration.padEnd(width)}  ${ref}  ${result.pr.title}`);
+    }
+  }
+}
+async function analyzeAuthoredSizes({ authored, sizeTarget, charts }) {
+  const prs = authored.map((item) => {
+    return {
+      repo: item.repository.nameWithOwner,
+      number: item.number,
+      title: item.title,
+      url: item.url,
+      createdAt: new Date(item.createdAt)
+    };
+  });
+  if (prs.length === 0) {
+    console.info("\nNo authored PRs found.");
+    return;
+  }
+  if (authored.length >= 1e3) {
+    console.warn("Warning, the authored search hit the 1000 result cap, so data may be incomplete.");
+  }
+  console.info(`
+Found ${prs.length} authored PRs, fetching sizes...`);
+  const sizes = [];
+  const batchSize = 25;
+  for (let offset = 0; offset < prs.length; offset += batchSize) {
+    const batch = prs.slice(offset, offset + batchSize);
+    const detailsList = await fetchPrSizes(batch);
+    for (const [i, pr] of batch.entries()) {
+      const details = detailsList[i];
+      if (details) {
+        sizes.push({
+          pr,
+          files: details.changedFiles,
+          additions: details.additions,
+          deletions: details.deletions,
+          total: details.additions + details.deletions
+        });
+      }
+    }
+    process.stdout.write(`\r  ${Math.min(offset + batchSize, prs.length)}/${prs.length}`);
+  }
+  process.stdout.write("\n");
+  if (sizes.length === 0) {
+    console.info("No accessible authored PRs to analyze.");
+    return;
+  }
+  if (sizes.length < prs.length) {
+    console.info(`${prs.length - sizes.length} authored PRs were inaccessible and are excluded.`);
+  }
+  const metrics = [
+    { label: "files changed", values: sizes.map((size) => size.files) },
+    { label: "lines added", values: sizes.map((size) => size.additions) },
+    { label: "lines removed", values: sizes.map((size) => size.deletions) },
+    { label: "lines total", values: sizes.map((size) => size.total) }
+  ];
+  printSizeStats(`Authored PR sizes (n=${sizes.length})`, metrics);
+  const meetsTarget = (size) => (sizeTarget.lines === void 0 || size.total <= sizeTarget.lines) && (sizeTarget.files === void 0 || size.files <= sizeTarget.files);
+  if (sizeTarget !== void 0) {
+    const targetLabel = [
+      ...sizeTarget.lines === void 0 ? [] : [`<= ${sizeTarget.lines} lines`],
+      ...sizeTarget.files === void 0 ? [] : [`<= ${sizeTarget.files} files`]
+    ].join(", ");
+    const met = sizes.filter((size) => meetsTarget(size)).length;
+    const pct = met / sizes.length * 100;
+    const filled = Math.round(pct / 100 * 30);
+    const gauge = "\u2588".repeat(filled) + "\u2591".repeat(30 - filled);
+    console.info(`  target ${targetLabel}  ${gauge} ${pct.toFixed(0)}% met (${met}/${sizes.length})`);
+  }
+  if (charts.has("histogram")) {
+    printHistogram(
+      `Authored PR sizes, lines total (n=${sizes.length})`,
+      sizes.map((size) => size.total),
+      LINE_BUCKETS
+    );
+    printHistogram(
+      `Authored PR sizes, files changed (n=${sizes.length})`,
+      sizes.map((size) => size.files),
+      FILE_BUCKETS
+    );
+  }
+  if (charts.has("strip")) {
+    printQuantileStrips("Authored PR size spread, log scale (\u2592 p25-p75, \u2588 p50)", metrics);
+  }
+  if (charts.has("spark")) {
+    const chronological = [...sizes].toSorted((a, b) => a.pr.createdAt - b.pr.createdAt);
+    printSizeTimeline(chronological.map((size) => size.total));
+  }
+  if (sizeTarget === void 0) {
+    return;
+  }
+  const misses = sizes.filter((size) => !meetsTarget(size)).toSorted((a, b) => b.total - a.total);
+  if (misses.length === 0) {
+    return;
+  }
+  console.info("\nAuthored PRs over the size target");
+  const rows = misses.map((size) => {
+    return {
+      size,
+      desc: `+${size.additions}/-${size.deletions}, ${size.files} files`
+    };
+  });
+  const width = Math.max(...rows.map((row) => row.desc.length));
+  for (const { size, desc } of rows) {
+    const ref = link(`${size.pr.repo}#${size.pr.number}`, size.pr.url);
+    console.info(`  ${desc.padEnd(width)}  ${ref}  ${size.pr.title}`);
+  }
+}
+
+// ../../node_modules/.pnpm/chalk@6.0.0/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, postfix) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + postfix;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const isGotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, isGotCR ? index - 1 : index) + prefix + (isGotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// ../../node_modules/.pnpm/chalk@6.0.0/node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var ANSI_UNDERLINE_OFFSET = 20;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var wrapUnderlineAnsi = (code) => `\x1B[58;5;${code < 90 ? code - 30 : code - 90 + 8}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    // Extended underline styles (`SGR 4:x` sub-parameters). Not in upstream `ansi-styles`.
+    underlineDouble: ["4:2", 24],
+    underlineCurly: ["4:3", 24],
+    underlineDotted: ["4:4", 24],
+    underlineDashed: ["4:5", 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  },
+  // Underline color (`SGR 58`/`59`). Not in upstream `ansi-styles`.
+  underlineColor: {
+    underlineBlack: ["58;5;0", 59],
+    underlineRed: ["58;5;1", 59],
+    underlineGreen: ["58;5;2", 59],
+    underlineYellow: ["58;5;3", 59],
+    underlineBlue: ["58;5;4", 59],
+    underlineMagenta: ["58;5;5", 59],
+    underlineCyan: ["58;5;6", 59],
+    underlineWhite: ["58;5;7", 59],
+    // Bright color
+    underlineBlackBright: ["58;5;8", 59],
+    underlineGray: ["58;5;8", 59],
+    // Alias of `underlineBlackBright`
+    underlineGrey: ["58;5;8", 59],
+    // Alias of `underlineBlackBright`
+    underlineRedBright: ["58;5;9", 59],
+    underlineGreenBright: ["58;5;10", 59],
+    underlineYellowBright: ["58;5;11", 59],
+    underlineBlueBright: ["58;5;12", 59],
+    underlineMagentaBright: ["58;5;13", 59],
+    underlineCyanBright: ["58;5;14", 59],
+    underlineWhiteBright: ["58;5;15", 59]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var underlineColorNames = Object.keys(styles.underlineColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(Number.parseInt(style[0], 10), style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.underlineColor.close = "\x1B[59m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  styles.underlineColor.ansi = wrapUnderlineAnsi;
+  styles.underlineColor.ansi256 = wrapAnsi256(ANSI_UNDERLINE_OFFSET);
+  styles.underlineColor.ansi16m = wrapAnsi16m(ANSI_UNDERLINE_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[\da-f]{6}|[\da-f]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise -- We need the speed */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value2 = Math.max(red, green, blue) * 2;
+        if (value2 === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value2 === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// ../../node_modules/.pnpm/chalk@6.0.0/node_modules/chalk/source/vendor/supports-color/index.js
+import process2 from "node:process";
+import os from "node:os";
+import tty from "node:tty";
+function hasFlag(flag2, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag2.startsWith("-") ? "" : flag2.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag2);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process2;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function hasNumericForceColor() {
+  return /^\d+$/.test(env.FORCE_COLOR);
+}
+function envForceColor() {
+  if (!("FORCE_COLOR" in env)) {
+    return;
+  }
+  if (env.FORCE_COLOR === "false") {
+    return 0;
+  }
+  if (env.FORCE_COLOR === "true" || env.FORCE_COLOR.length === 0) {
+    return 1;
+  }
+  if (!hasNumericForceColor()) {
+    return;
+  }
+  return Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if (forceColor !== void 0 && hasNumericForceColor()) {
+    return forceColor;
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(?:9\.0*[1-9]\d*\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".", 1)[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(?:color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// ../../node_modules/.pnpm/chalk@6.0.0/node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+var STYLER = /* @__PURE__ */ Symbol("STYLER");
+var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+var LEVEL = /* @__PURE__ */ Symbol("LEVEL");
+var styles2 = /* @__PURE__ */ Object.create(null);
+var assertValidLevel = (level) => {
+  if (!Number.isSafeInteger(level) || level < 0 || level > 3) {
+    throw new Error("The `level` should be an integer from 0 to 3");
+  }
+};
+var levelDescriptor = {
+  enumerable: true,
+  get() {
+    return this[LEVEL];
+  },
+  set(level) {
+    assertValidLevel(level);
+    this[LEVEL] = level;
+  }
+};
+var applyOptions = (object, options = {}) => {
+  if (options.level !== void 0) {
+    assertValidLevel(options.level);
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object[LEVEL] = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var createModelConverters = (model, type) => {
+  const style = ansi_styles_default[type];
+  if (model === "rgb") {
+    const ansi2 = (red, green, blue) => style.ansi(ansi_styles_default.rgbToAnsi(red, green, blue));
+    const ansi256 = (red, green, blue) => style.ansi256(ansi_styles_default.rgbToAnsi256(red, green, blue));
+    return [ansi2, ansi2, ansi256, style.ansi16m];
+  }
+  if (model === "hex") {
+    const ansi2 = (hex) => style.ansi(ansi_styles_default.hexToAnsi(hex));
+    const ansi256 = (hex) => style.ansi256(ansi_styles_default.hexToAnsi256(hex));
+    return [ansi2, ansi2, ansi256, (hex) => style.ansi16m(...ansi_styles_default.hexToRgb(hex))];
+  }
+  const ansi = (code) => style.ansi(ansi_styles_default.ansi256ToAnsi(code));
+  return [ansi, ansi, style.ansi256, style.ansi256];
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  const capitalizedModel = model[0].toUpperCase() + model.slice(1);
+  for (const [styleName, type] of [
+    [model, "color"],
+    ["bg" + capitalizedModel, "bgColor"],
+    ["underline" + capitalizedModel, "underlineColor"]
+  ]) {
+    const { close } = ansi_styles_default[type];
+    const converters = createModelConverters(model, type);
+    styles2[styleName] = {
+      get() {
+        const styleFunction = function(first, second, third) {
+          const open = converters[this.level](first, second, third);
+          return createBuilder(this, createStyler(open, close, this[STYLER]), this[IS_EMPTY]);
+        };
+        Object.defineProperty(this, styleName, { value: styleFunction });
+        return styleFunction;
+      }
+    };
+  }
+}
+var proto = Object.defineProperties(
+  () => {
+  },
+  {
+    ...styles2,
+    level: {
+      enumerable: true,
+      get() {
+        return this[GENERATOR].level;
+      },
+      set(level) {
+        this[GENERATOR].level = level;
+      }
+    }
+  }
+);
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => {
+    if (arguments_.length === 1) {
+      return applyStyle(builder, "" + arguments_[0]);
+    }
+    if (arguments_.length === 2) {
+      return applyStyle(builder, arguments_[0] + " " + arguments_[1]);
+    }
+    return applyStyle(builder, arguments_.join(" "));
+  };
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self[GENERATOR] ?? self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self[GENERATOR][LEVEL] <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, { ...styles2, level: levelDescriptor });
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// cli.mjs
+import { parseArgs } from "node:util";
+var flag = source_default.green;
+var value = source_default.cyan;
+var dim = source_default.dim;
+var OPTIONS = [
+  {
+    name: "since",
+    short: "s",
+    type: "string",
+    default: "90d",
+    placeholder: "<value>",
+    help: "Only include PRs created after this point. Accepts an ISO date (`2026-01-01`) or a relative value (`30d`, `8w`, `6m`, `1y`). The default is `90d`."
+  },
+  {
+    name: "repo",
+    short: "r",
+    type: "string",
+    multiple: true,
+    default: [],
+    placeholder: "<name>",
+    help: 'Restrict the search to a repository. Repeat the flag for multiple repositories. Accepts "owner/name" or a bare name, which resolves against the owner of the repo in the current directory. Without this flag, all repositories you have access to are searched.'
+  },
+  {
+    name: "user",
+    short: "u",
+    type: "string",
+    placeholder: "<login>",
+    help: "Compute stats for this user. Defaults to the authenticated user."
+  },
+  {
+    name: "token",
+    type: "string",
+    placeholder: "<token>",
+    help: "GitHub access token. When set, the tool calls the GitHub API directly instead of going through the gh CLI. The `GITHUB_TOKEN` and `GH_TOKEN` environment variables work as well."
+  },
+  {
+    name: "reports",
+    type: "string",
+    default: "review-time,size",
+    placeholder: "<list>",
+    help: "Choose which reports to print as a comma-separated list. Accepts `review-time` (how fast you finish review requests) and `size` (how large your authored PRs are). Both print by default."
+  },
+  {
+    name: "target",
+    short: "t",
+    type: "string",
+    placeholder: "<value>",
+    help: "Report how many reviews finished within this time. Accepts hours (`24h` or plain `24`), minutes (`90m`), or days (`2d`). A day means 24 counted hours, or one working day when --work-hours is set. Open PRs that have already waited longer than the target count as misses."
+  },
+  {
+    name: "size-target",
+    type: "string",
+    placeholder: "<v>",
+    help: "Report how many authored PRs fit within this size. Accepts a line budget (`400` or `400l`), a file budget (`20f`), or both (`400l,20f`). Lines count additions plus deletions."
+  },
+  {
+    name: "charts",
+    short: "c",
+    type: "string",
+    default: "histogram,strip,spark",
+    placeholder: "<list>",
+    help: "Choose which size charts to print as a comma-separated list. Accepts `histogram` (size distribution bars), `strip` (a quantile strip per metric), and `spark` (a size line chart over time). All three print by default. Pass `none` to print no charts."
+  },
+  {
+    name: "tz",
+    type: "string",
+    placeholder: "<zone>",
+    help: "IANA timezone for the weekend and working-hours math, for example `Europe/Berlin`. Defaults to your system timezone."
+  },
+  {
+    name: "work-hours",
+    short: "w",
+    type: "string",
+    default: "0-24",
+    placeholder: "<v>",
+    help: "Count only these working hours instead of full weekdays. Accepts one range like `9-17` or `8:30-16:30`, or several comma-separated ranges like `9-18,19:30-20:30`. Without this flag, every hour Mon-Fri counts."
+  },
+  {
+    name: "wall-clock",
+    type: "boolean",
+    default: false,
+    help: "Measure raw elapsed time, including weekends."
+  },
+  {
+    name: "include-drafts",
+    type: "boolean",
+    default: false,
+    help: "Include PRs that are currently drafts. Excluded by default."
+  },
+  {
+    name: "help",
+    short: "h",
+    type: "boolean",
+    default: false,
+    help: "Show this help."
+  }
+];
+var HELP_WIDTH = Math.min(process.stdout.columns ?? 80, 120);
+function colorizeHelp(text) {
+  return text.replaceAll(/`([^`]+)`/g, (match, span) => value(span)).replaceAll(/"[^"]*"/g, (span) => source_default.yellow(span)).replaceAll(/--[a-z][a-z-]*/g, (span) => flag(span));
+}
+function wrapMarkup(text, width) {
+  const lines = [];
+  let line = "";
+  for (const word of text.split(" ")) {
+    const candidate = line === "" ? word : `${line} ${word}`;
+    if (line !== "" && candidate.replaceAll("`", "").length > width) {
+      lines.push(line);
+      line = word;
+    } else {
+      line = candidate;
+    }
+  }
+  if (line !== "") {
+    lines.push(line);
+  }
+  return lines;
+}
+function renderHelp() {
+  const labels = OPTIONS.map((option) => {
+    const short = option.short ? `-${option.short}, ` : "";
+    const long = option.placeholder ? `--${option.name} ${option.placeholder}` : `--${option.name}`;
+    return short + long;
+  });
+  const column = Math.max(...labels.map((label) => label.length)) + 4;
+  const lines = [`${source_default.bold("Usage:")} ${source_default.bold("pr-stats")} ${dim("[options]")}`, "", source_default.bold("Options:")];
+  for (const [index, option] of OPTIONS.entries()) {
+    const short = option.short ? `${flag(`-${option.short}`)}, ` : "";
+    const long = option.placeholder ? `${flag(`--${option.name}`)} ${dim(option.placeholder)}` : flag(`--${option.name}`);
+    const body = wrapMarkup(option.help, HELP_WIDTH - column).map((line) => colorizeHelp(line));
+    lines.push(`  ${short}${long}${" ".repeat(column - 2 - labels[index].length)}${body[0]}`);
+    for (const overflow of body.slice(1)) {
+      lines.push(" ".repeat(column) + overflow);
+    }
+  }
+  return lines.join("\n");
+}
+var HELP = renderHelp();
+function parseCliArgs() {
+  const options = {};
+  for (const option of OPTIONS) {
+    options[option.name] = { type: option.type };
+    if (option.short) {
+      options[option.name].short = option.short;
+    }
+    if (option.multiple) {
+      options[option.name].multiple = true;
+    }
+    if (option.default !== void 0) {
+      options[option.name].default = option.default;
+    }
+  }
+  const { values } = parseArgs({ options });
+  return values;
+}
+function parseSince(value2) {
+  const relative = /^(\d+)([dwmy])$/.exec(value2);
+  if (relative) {
+    const amount = Number(relative[1]);
+    const date2 = /* @__PURE__ */ new Date();
+    if (relative[2] === "d") {
+      date2.setDate(date2.getDate() - amount);
+    }
+    if (relative[2] === "w") {
+      date2.setDate(date2.getDate() - amount * 7);
+    }
+    if (relative[2] === "m") {
+      date2.setMonth(date2.getMonth() - amount);
+    }
+    if (relative[2] === "y") {
+      date2.setFullYear(date2.getFullYear() - amount);
+    }
+    return date2;
+  }
+  const date = new Date(value2);
+  if (Number.isNaN(date.getTime())) {
+    fail(`invalid --since value "${value2}", use an ISO date or 30d/8w/6m/1y`);
+  }
+  return date;
+}
+function parseTarget(value2) {
+  const match = /^(\d+(?:\.\d+)?)([hdm]?)$/.exec(value2);
+  if (!match) {
+    fail(`invalid --target value "${value2}", use 24h, 2d, or 90m`);
+  }
+  const amount = Number(match[1]);
+  if (match[2] === "d") {
+    return amount * timeMode.dayHours;
+  }
+  if (match[2] === "m") {
+    return amount / 60;
+  }
+  return amount;
+}
+function parseSizeTarget(value2) {
+  const target = {};
+  for (const part of value2.split(",")) {
+    const match = /^(\d+)([lf]?)$/.exec(part.trim());
+    if (!match) {
+      fail(`invalid --size-target value "${value2}", use 400, 400l, 20f, or 400l,20f`);
+    }
+    const key = match[2] === "f" ? "files" : "lines";
+    if (target[key] !== void 0) {
+      fail(`--size-target sets the ${key} budget twice`);
+    }
+    target[key] = Number(match[1]);
+  }
+  return target;
+}
+function parseReports(value2) {
+  const names = /* @__PURE__ */ new Set(["review-time", "size"]);
+  const parts = value2.split(",").map((part) => part.trim()).filter((part) => part !== "");
+  const reports = /* @__PURE__ */ new Set();
+  for (const part of parts) {
+    if (!names.has(part)) {
+      fail(
+        `invalid ${flag("--reports")} value "${part}", use a comma-separated list of ${value2("review-time")} and ${value2("size")}`
+      );
+    }
+    reports.add(part);
+  }
+  if (reports.size === 0) {
+    fail(`--reports needs at least one of ${value2("review-time")} and ${value2("size")}`);
+  }
+  return reports;
+}
+function parseCharts(value2) {
+  const aliases = {
+    histogram: "histogram",
+    hist: "histogram",
+    strip: "strip",
+    spark: "spark",
+    sparkline: "spark"
+  };
+  const parts = value2.split(",").map((part) => part.trim().toLowerCase()).filter((part) => part !== "");
+  if (parts.length === 1 && parts[0] === "none") {
+    return /* @__PURE__ */ new Set();
+  }
+  const charts = /* @__PURE__ */ new Set();
+  for (const part of parts) {
+    const name = aliases[part];
+    if (name === void 0) {
+      fail(`invalid --charts value "${part}", use a comma-separated list of histogram, strip, spark, or none`);
+    }
+    charts.add(name);
+  }
+  return charts;
+}
+function parseWorkHours(value2) {
+  const windows = value2.split(",").map((range) => {
+    const match = /^(\d{1,2})(?::(\d{2}))?-(\d{1,2})(?::(\d{2}))?$/.exec(range.trim());
+    if (!match) {
+      fail(`invalid --work-hours range "${range}", use ranges like 9-17, 8:30-16:30, or 9-18,19:30-20:30`);
+    }
+    const startMin = Number(match[1]) * 60 + Number(match[2] ?? 0);
+    const endMin = Number(match[3]) * 60 + Number(match[4] ?? 0);
+    if (endMin <= startMin || endMin > 24 * 60 || Number(match[2] ?? 0) > 59 || Number(match[4] ?? 0) > 59) {
+      fail(`invalid --work-hours range "${range}"`);
+    }
+    return { startMin, endMin };
+  });
+  windows.sort((a, b) => a.startMin - b.startMin);
+  for (let i = 1; i < windows.length; i++) {
+    if (windows[i].startMin < windows[i - 1].endMin) {
+      fail(`--work-hours ranges overlap around ${formatMinutesOfDay(windows[i].startMin)}`);
+    }
+  }
+  return windows;
+}
+function resolveTimezone(value2) {
+  const tz = value2 ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+  } catch {
+    fail(`invalid --tz value "${tz}", use an IANA zone like Europe/Berlin`);
+  }
+  return tz;
+}
+
+// index.mjs
+async function main() {
+  const values = parseCliArgs();
+  if (values.help) {
+    console.info(HELP);
+    return;
+  }
+  configureAuth(values.token);
+  const since = parseSince(values.since);
+  const sinceIso = since.toISOString().slice(0, 10);
+  const tz = resolveTimezone(values.tz);
+  const workWindows = parseWorkHours(values["work-hours"]);
+  configureTimeMode({ business: !values["wall-clock"], workWindows, tz });
+  initBuckets();
+  const targetHours = values.target !== void 0 ? parseTarget(values.target) : void 0;
+  const targetLabel = values.target !== void 0 ? values.target + (/^[\d.]+$/.test(values.target) ? "h" : "") : void 0;
+  const sizeTarget = values["size-target"] !== void 0 ? parseSizeTarget(values["size-target"]) : void 0;
+  const charts = parseCharts(values.charts);
+  const reports = parseReports(values.reports);
+  const user = values.user ?? await fetchCurrentUser();
+  const repos = await resolveRepos(values.repo);
+  const includeDrafts = values["include-drafts"];
+  console.info(
+    `Searching PRs since ${sinceIso} for @${user}` + (repos.length > 0 ? ` in ${repos.join(", ")}` : " across all accessible repos") + (includeDrafts ? " (drafts included)" : "")
+  );
+  if (isFullDayMode()) {
+    console.info(`Durations count all hours Mon-Fri and skip weekends in ${tz}.`);
+  } else if (timeMode.business) {
+    const windowsText = workWindows.map((window) => `${formatMinutesOfDay(window.startMin)}-${formatMinutesOfDay(window.endMin)}`).join(", ");
+    console.info(`Durations count working hours only, Mon-Fri ${windowsText} in ${tz} (1wd = ${timeMode.dayHours}h)`);
+  } else {
+    console.info("Durations are wall-clock time.");
+  }
+  const [requested, reviewed, authored] = await Promise.all([
+    reports.has("review-time") ? searchPrs({ user, sinceIso, repos, includeDrafts, mode: "requested" }) : [],
+    reports.has("review-time") ? searchPrs({ user, sinceIso, repos, includeDrafts, mode: "reviewed" }) : [],
+    reports.has("size") ? searchPrs({ user, sinceIso, repos, includeDrafts, mode: "authored" }) : []
+  ]);
+  if (reports.has("review-time")) {
+    await analyzeReviewTimes({ requested, reviewed, user, targetHours, targetLabel });
+  }
+  if (reports.has("size")) {
+    await analyzeAuthoredSizes({ authored, sizeTarget, charts });
+  }
+}
+await main();