Codex
381 lines
13 KiB
TypeScript
381 lines
13 KiB
TypeScript
#!/usr/bin/env bun
|
|
|
|
type OutputFormat = "table" | "json" | "csv";
|
|
|
|
type Options = {
|
|
repo: string;
|
|
output: OutputFormat;
|
|
since: Date | null;
|
|
until: Date | null;
|
|
limit: number | null;
|
|
examples: number;
|
|
caseSensitive: boolean;
|
|
token: string | null;
|
|
};
|
|
|
|
type PullRecord = {
|
|
number: number;
|
|
title: string;
|
|
url: string;
|
|
mergedAt: string;
|
|
headOid: string | null;
|
|
email: string | null;
|
|
authorName: string | null;
|
|
authorLogin: string | null;
|
|
};
|
|
|
|
type EmailStat = {
|
|
email: string;
|
|
count: number;
|
|
prs: PullRecord[];
|
|
};
|
|
|
|
const defaultRepo = "pikasTech/PikaPython";
|
|
|
|
async function main(): Promise<void> {
|
|
const options = parseArgs(Bun.argv.slice(2));
|
|
const repo = parseRepo(options.repo);
|
|
const pulls = await fetchMergedPulls(repo.owner, repo.name, options);
|
|
const filtered = pulls.filter((pr) => withinDateRange(pr.mergedAt, options.since, options.until));
|
|
const selected = options.limit === null ? filtered : filtered.slice(0, options.limit);
|
|
const stats = summarize(selected, options);
|
|
|
|
if (options.output === "json") {
|
|
printJson(options, selected, stats);
|
|
} else if (options.output === "csv") {
|
|
printCsv(selected, stats);
|
|
} else {
|
|
printTable(options, selected, stats);
|
|
}
|
|
}
|
|
|
|
function parseArgs(args: string[]): Options {
|
|
const options: Options = {
|
|
repo: defaultRepo,
|
|
output: "table",
|
|
since: null,
|
|
until: null,
|
|
limit: null,
|
|
examples: 6,
|
|
caseSensitive: false,
|
|
token: process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN ?? null,
|
|
};
|
|
|
|
for (let index = 0; index < args.length; index += 1) {
|
|
const arg = args[index];
|
|
if (arg === "--help" || arg === "-h") {
|
|
printHelp();
|
|
process.exit(0);
|
|
}
|
|
if (arg === "--repo") {
|
|
options.repo = requireValue(args, ++index, arg);
|
|
} else if (arg.startsWith("--repo=")) {
|
|
options.repo = arg.slice("--repo=".length);
|
|
} else if (arg === "--json") {
|
|
options.output = "json";
|
|
} else if (arg === "--csv") {
|
|
options.output = "csv";
|
|
} else if (arg === "--since") {
|
|
options.since = parseDateArg(requireValue(args, ++index, arg), arg);
|
|
} else if (arg.startsWith("--since=")) {
|
|
options.since = parseDateArg(arg.slice("--since=".length), "--since");
|
|
} else if (arg === "--until") {
|
|
options.until = parseDateArg(requireValue(args, ++index, arg), arg);
|
|
} else if (arg.startsWith("--until=")) {
|
|
options.until = parseDateArg(arg.slice("--until=".length), "--until");
|
|
} else if (arg === "--limit") {
|
|
options.limit = parsePositiveInt(requireValue(args, ++index, arg), arg);
|
|
} else if (arg.startsWith("--limit=")) {
|
|
options.limit = parsePositiveInt(arg.slice("--limit=".length), "--limit");
|
|
} else if (arg === "--examples") {
|
|
options.examples = parsePositiveInt(requireValue(args, ++index, arg), arg);
|
|
} else if (arg.startsWith("--examples=")) {
|
|
options.examples = parsePositiveInt(arg.slice("--examples=".length), "--examples");
|
|
} else if (arg === "--case-sensitive") {
|
|
options.caseSensitive = true;
|
|
} else if (arg === "--token") {
|
|
options.token = requireValue(args, ++index, arg);
|
|
} else if (arg.startsWith("--token=")) {
|
|
options.token = arg.slice("--token=".length);
|
|
} else {
|
|
throw new Error(`unknown argument: ${arg}`);
|
|
}
|
|
}
|
|
|
|
return options;
|
|
}
|
|
|
|
function printHelp(): void {
|
|
console.log(`Analyze merged GitHub PR counts by head commit author email.
|
|
|
|
Usage:
|
|
bun scripts/analyze-github-merged-pr-emails.ts [options]
|
|
|
|
Options:
|
|
--repo owner/name GitHub repo. Default: ${defaultRepo}
|
|
--since YYYY-MM-DD Include PRs merged at or after this UTC date.
|
|
--until YYYY-MM-DD Include PRs merged before or at this UTC date.
|
|
--limit N Limit merged PR records after date filtering.
|
|
--examples N Number of example PR numbers in table output. Default: 6
|
|
--json Print machine-readable JSON.
|
|
--csv Print CSV.
|
|
--case-sensitive Do not lowercase emails before grouping.
|
|
--token TOKEN GitHub token. Defaults to GITHUB_TOKEN or GH_TOKEN.
|
|
|
|
Definition:
|
|
A real PR is a pull request whose GitHub state is MERGED.
|
|
Each merged PR is counted once, using the author email of the PR head commit.
|
|
`);
|
|
}
|
|
|
|
function requireValue(args: string[], index: number, flag: string): string {
|
|
const value = args[index];
|
|
if (value === undefined || value.startsWith("--")) {
|
|
throw new Error(`${flag} requires a value`);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function parseDateArg(value: string, flag: string): Date {
|
|
const normalized = /^\d{4}-\d{2}-\d{2}$/.test(value) ? `${value}T00:00:00.000Z` : value;
|
|
const parsed = new Date(normalized);
|
|
if (Number.isNaN(parsed.getTime())) {
|
|
throw new Error(`${flag} must be a valid date, got: ${value}`);
|
|
}
|
|
return parsed;
|
|
}
|
|
|
|
function parsePositiveInt(value: string, flag: string): number {
|
|
const parsed = Number(value);
|
|
if (!Number.isInteger(parsed) || parsed < 1) {
|
|
throw new Error(`${flag} must be a positive integer, got: ${value}`);
|
|
}
|
|
return parsed;
|
|
}
|
|
|
|
function parseRepo(repo: string): { owner: string; name: string } {
|
|
const cleaned = repo.replace(/^https:\/\/github\.com\//, "").replace(/\.git$/, "");
|
|
const parts = cleaned.split("/");
|
|
if (parts.length !== 2 || parts[0] === "" || parts[1] === "") {
|
|
throw new Error(`repo must be owner/name or github.com URL, got: ${repo}`);
|
|
}
|
|
return { owner: parts[0], name: parts[1] };
|
|
}
|
|
|
|
async function fetchMergedPulls(owner: string, name: string, options: Options): Promise<PullRecord[]> {
|
|
if (options.token === null || options.token.trim() === "") {
|
|
throw new Error("GitHub GraphQL requires a token; set GITHUB_TOKEN/GH_TOKEN or pass --token");
|
|
}
|
|
|
|
const query = `
|
|
query($owner: String!, $name: String!, $cursor: String) {
|
|
repository(owner: $owner, name: $name) {
|
|
pullRequests(states: MERGED, first: 100, after: $cursor, orderBy: {field: CREATED_AT, direction: DESC}) {
|
|
nodes {
|
|
number
|
|
title
|
|
url
|
|
mergedAt
|
|
commits(last: 1) {
|
|
nodes {
|
|
commit {
|
|
oid
|
|
author {
|
|
name
|
|
email
|
|
user { login }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pageInfo {
|
|
hasNextPage
|
|
endCursor
|
|
}
|
|
}
|
|
}
|
|
rateLimit {
|
|
remaining
|
|
resetAt
|
|
}
|
|
}`;
|
|
|
|
const pulls: PullRecord[] = [];
|
|
let cursor: string | null = null;
|
|
|
|
while (true) {
|
|
const payload = await githubGraphql(options.token, query, { owner, name, cursor });
|
|
const repository = asRecord(payload.data)?.repository;
|
|
const pullRequests = asRecord(repository)?.pullRequests;
|
|
const nodes = asArray(asRecord(pullRequests)?.nodes);
|
|
for (const node of nodes) {
|
|
const pr = parsePullNode(node);
|
|
if (pr !== null) pulls.push(pr);
|
|
}
|
|
const pageInfo = asRecord(asRecord(pullRequests)?.pageInfo);
|
|
const hasNextPage = pageInfo?.hasNextPage === true;
|
|
cursor = typeof pageInfo?.endCursor === "string" ? pageInfo.endCursor : null;
|
|
if (!hasNextPage || cursor === null) break;
|
|
}
|
|
|
|
return pulls;
|
|
}
|
|
|
|
async function githubGraphql(token: string, query: string, variables: Record<string, unknown>): Promise<Record<string, unknown>> {
|
|
const response = await fetch("https://api.github.com/graphql", {
|
|
method: "POST",
|
|
headers: {
|
|
"Accept": "application/vnd.github+json",
|
|
"Authorization": `Bearer ${token}`,
|
|
"Content-Type": "application/json",
|
|
"User-Agent": "unidesk-pr-email-stats",
|
|
"X-GitHub-Api-Version": "2022-11-28",
|
|
},
|
|
body: JSON.stringify({ query, variables }),
|
|
});
|
|
const body = await response.text();
|
|
let parsed: unknown;
|
|
try {
|
|
parsed = JSON.parse(body);
|
|
} catch {
|
|
throw new Error(`GitHub GraphQL returned non-JSON status=${response.status}: ${body.slice(0, 500)}`);
|
|
}
|
|
const record = asRecord(parsed);
|
|
if (record === null) {
|
|
throw new Error("GitHub GraphQL returned a non-object response");
|
|
}
|
|
if (!response.ok || record.errors !== undefined) {
|
|
throw new Error(`GitHub GraphQL failed status=${response.status}: ${JSON.stringify(record.errors ?? record)}`);
|
|
}
|
|
return record;
|
|
}
|
|
|
|
function parsePullNode(node: unknown): PullRecord | null {
|
|
const record = asRecord(node);
|
|
if (record === null) return null;
|
|
const number = typeof record.number === "number" ? record.number : null;
|
|
const title = typeof record.title === "string" ? record.title : "";
|
|
const url = typeof record.url === "string" ? record.url : "";
|
|
const mergedAt = typeof record.mergedAt === "string" ? record.mergedAt : null;
|
|
const commitNode = asArray(asRecord(record.commits)?.nodes)[0];
|
|
const commit = asRecord(asRecord(commitNode)?.commit);
|
|
const author = asRecord(commit?.author);
|
|
if (number === null || mergedAt === null) return null;
|
|
return {
|
|
number,
|
|
title,
|
|
url,
|
|
mergedAt,
|
|
headOid: typeof commit?.oid === "string" ? commit.oid : null,
|
|
email: typeof author?.email === "string" && author.email.trim() !== "" ? author.email : null,
|
|
authorName: typeof author?.name === "string" && author.name.trim() !== "" ? author.name : null,
|
|
authorLogin: typeof asRecord(author?.user)?.login === "string" ? String(asRecord(author?.user)?.login) : null,
|
|
};
|
|
}
|
|
|
|
function withinDateRange(value: string, since: Date | null, until: Date | null): boolean {
|
|
const time = Date.parse(value);
|
|
if (Number.isNaN(time)) return false;
|
|
if (since !== null && time < since.getTime()) return false;
|
|
if (until !== null && time > until.getTime()) return false;
|
|
return true;
|
|
}
|
|
|
|
function summarize(pulls: PullRecord[], options: Options): EmailStat[] {
|
|
const byEmail = new Map<string, PullRecord[]>();
|
|
for (const pr of pulls) {
|
|
const rawEmail = pr.email ?? "(unknown)";
|
|
const email = options.caseSensitive ? rawEmail : rawEmail.toLowerCase();
|
|
const list = byEmail.get(email) ?? [];
|
|
list.push(pr);
|
|
byEmail.set(email, list);
|
|
}
|
|
return [...byEmail.entries()]
|
|
.map(([email, prs]) => ({ email, count: prs.length, prs }))
|
|
.sort((left, right) => right.count - left.count || left.email.localeCompare(right.email));
|
|
}
|
|
|
|
function printTable(options: Options, pulls: PullRecord[], stats: EmailStat[]): void {
|
|
console.log(`MERGED_PR_EMAIL_STATS repo=${options.repo} source=head-commit-author total=${pulls.length}`);
|
|
if (options.since !== null || options.until !== null) {
|
|
console.log(`RANGE since=${options.since?.toISOString() ?? "-"} until=${options.until?.toISOString() ?? "-"}`);
|
|
}
|
|
console.log("");
|
|
const rows = stats.map((stat) => ({
|
|
EMAIL: stat.email,
|
|
PRS: String(stat.count),
|
|
PERCENT: pulls.length === 0 ? "0.0%" : `${((stat.count / pulls.length) * 100).toFixed(1)}%`,
|
|
EXAMPLES: stat.prs.slice(0, options.examples).map((pr) => `#${pr.number}`).join(","),
|
|
}));
|
|
printRows(rows, ["EMAIL", "PRS", "PERCENT", "EXAMPLES"]);
|
|
console.log("");
|
|
console.log("Definition: merged PRs only; one PR counts once under the author email of its head commit.");
|
|
}
|
|
|
|
function printRows(rows: Array<Record<string, string>>, columns: string[]): void {
|
|
const widths = new Map<string, number>();
|
|
for (const column of columns) {
|
|
widths.set(column, Math.max(column.length, ...rows.map((row) => row[column]?.length ?? 0)));
|
|
}
|
|
const line = (row: Record<string, string>): string => columns
|
|
.map((column) => (row[column] ?? "").padEnd(widths.get(column) ?? column.length))
|
|
.join(" ")
|
|
.trimEnd();
|
|
console.log(line(Object.fromEntries(columns.map((column) => [column, column]))));
|
|
console.log(columns.map((column) => "-".repeat(widths.get(column) ?? column.length)).join(" "));
|
|
for (const row of rows) console.log(line(row));
|
|
}
|
|
|
|
function printJson(options: Options, pulls: PullRecord[], stats: EmailStat[]): void {
|
|
console.log(JSON.stringify({
|
|
repo: options.repo,
|
|
source: "head-commit-author",
|
|
totalMergedPullRequests: pulls.length,
|
|
since: options.since?.toISOString() ?? null,
|
|
until: options.until?.toISOString() ?? null,
|
|
stats: stats.map((stat) => ({
|
|
email: stat.email,
|
|
count: stat.count,
|
|
percent: pulls.length === 0 ? 0 : stat.count / pulls.length,
|
|
pullRequests: stat.prs.map((pr) => ({
|
|
number: pr.number,
|
|
mergedAt: pr.mergedAt,
|
|
headOid: pr.headOid,
|
|
authorName: pr.authorName,
|
|
authorLogin: pr.authorLogin,
|
|
title: pr.title,
|
|
url: pr.url,
|
|
})),
|
|
})),
|
|
}, null, 2));
|
|
}
|
|
|
|
function printCsv(pulls: PullRecord[], stats: EmailStat[]): void {
|
|
console.log(["email", "count", "percent", "pull_requests"].join(","));
|
|
for (const stat of stats) {
|
|
const percent = pulls.length === 0 ? "0" : String(stat.count / pulls.length);
|
|
const prs = stat.prs.map((pr) => `#${pr.number}`).join(" ");
|
|
console.log([csv(stat.email), stat.count, percent, csv(prs)].join(","));
|
|
}
|
|
}
|
|
|
|
function csv(value: string): string {
|
|
if (!/[",\n]/.test(value)) return value;
|
|
return `"${value.replaceAll("\"", "\"\"")}"`;
|
|
}
|
|
|
|
function asRecord(value: unknown): Record<string, unknown> | null {
|
|
return typeof value === "object" && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : null;
|
|
}
|
|
|
|
function asArray(value: unknown): unknown[] {
|
|
return Array.isArray(value) ? value : [];
|
|
}
|
|
|
|
main().catch((error: unknown) => {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
console.error(`error: ${message}`);
|
|
process.exit(1);
|
|
});
|